@ic-reactor/react 3.13.0 → 4.0.0-beta.2

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,YAAY,EACZ,uBAAuB,EACvB,SAAS,EACT,qBAAqB,EACtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,EACV,MAAM,uBAAuB,CAAA;AAQ9B,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,CAAA;AAKvD,uEAAuE;AACvE,MAAM,MAAM,WAAW,CACrB,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,IACvC,gBAAgB,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAA;AAEjE,iCAAiC;AACjC,MAAM,MAAM,UAAU,CACpB,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,IACvC,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAA;AAMhD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe,CAC9B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAClD,SAAQ,IAAI,CACZ,oBAAoB,CAClB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EACvC,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC5C,QAAQ,EACR,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EACvC,QAAQ,CACT,EACD,SAAS,GAAG,UAAU,CACvB;IACC,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAA;IAC9C;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,QAAQ,CAAA;CACrE;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,CACrB,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAChD,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,oBAAoB,CACnC,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAClD,SAAQ,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IACvE;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,GAAG,SAAS,CAAA;CAC3D;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAC7B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAChD,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;AAMzD;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAC5B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAChD,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAA;AAEnE;;GAEG;AACH,MAAM,MAAM,0BAA0B,CACpC,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAChD,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAA;AAM3E;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CACjC,YAAY,EACZ,SAAS,GAAG,YAAY,EACxB,MAAM,GAAG,KAAK;IAId,CACE,OAAO,CAAC,EAAE,IAAI,CACZ,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,CAAC,EAChD,UAAU,GAAG,SAAS,CACvB,GAAG;QACF,MAAM,CAAC,EAAE,SAAS,CAAA;KACnB,GACA,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;IAGpC,CAAC,MAAM,GAAG,SAAS,EACjB,OAAO,EAAE,IAAI,CACX,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7C,UAAU,GAAG,SAAS,GAAG,QAAQ,CAClC,GAAG;QACF,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,CAAA;KACpC,GACA,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,0BAA0B,CACzC,YAAY,EACZ,SAAS,GAAG,YAAY,EACxB,MAAM,GAAG,KAAK;IAId,CACE,OAAO,CAAC,EAAE,IAAI,CACZ,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,CAAC,EACxD,UAAU,GAAG,SAAS,CACvB,GAAG;QACF,MAAM,CAAC,EAAE,SAAS,CAAA;KACnB,GACA,sBAAsB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;IAG5C,CAAC,MAAM,GAAG,SAAS,EACjB,OAAO,EAAE,IAAI,CACX,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EACrD,UAAU,GAAG,SAAS,GAAG,QAAQ,CAClC,GAAG;QACF,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,CAAA;KACpC,GACA,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1C;AAMD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB,CAAC,YAAY;IAC9C;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3B;;;;;;;;;;;OAWG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,gBAAgB,EAAE,CAChB,OAAO,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,YAAY,KACzC,OAAO,CAAC,kBAAkB,CAAC,CAAA;CACjC;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,eAAe,CAC9B,YAAY,EACZ,SAAS,GAAG,YAAY,EACxB,OAAO,GAAG,KAAK,CACf,SAAQ,kBAAkB,CAAC,YAAY,CAAC;IACxC,kEAAkE;IAClE,KAAK,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,CAAA;IAE/B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE/B,qDAAqD;IACrD,WAAW,EAAE,MAAM,QAAQ,CAAA;IAE3B;;;;;;;;;;;;;;OAcG;IACH,YAAY,EAAE;QACZ,IAAI,SAAS,GAAG,SAAS,CAAA;QACzB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAClE,CAAA;IAED;;;;;;;;;;;;;OAaG;IACH,OAAO,EAAE,CACP,OAAO,EACH,YAAY,GACZ,CAAC,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,KAAK,YAAY,GAAG,SAAS,CAAC,KAC9D,YAAY,GAAG,SAAS,CAAA;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW,CAC1B,YAAY,EACZ,SAAS,GAAG,YAAY,EACxB,MAAM,GAAG,KAAK,CACd,SAAQ,eAAe,CAAC,YAAY,EAAE,SAAS,EAAE,MAAM,CAAC;IACxD,6EAA6E;IAC7E,QAAQ,EAAE,kBAAkB,CAAC,YAAY,EAAE,SAAS,EAAE,MAAM,CAAC,CAAA;CAC9D;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB,CAClC,YAAY,EACZ,SAAS,GAAG,YAAY,EACxB,MAAM,GAAG,KAAK,CACd,SAAQ,eAAe,CAAC,YAAY,EAAE,SAAS,EAAE,MAAM,CAAC;IACxD,4EAA4E;IAC5E,gBAAgB,EAAE,0BAA0B,CAAC,YAAY,EAAE,SAAS,EAAE,MAAM,CAAC,CAAA;CAC9E;AAMD;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,EAAE,MAAM,QAAQ,CAAA;IAC3B;;;;;;;;;;OAUG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAChC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,MAAM,CAAE,SAAQ,mBAAmB;IACxE,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,YAAY,CAAC,MAAM,SAAS;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,IAAI,IAAI,CACnE,MAAM,EACN,UAAU,CACX,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,uBAAuB,CACtC,KAAK,EACL,MAAM,SAAS;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CACpC,SAAQ,mBAAmB;IAG3B,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAA;IACrB,CAAC,IAAI,EAAE,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAA;IACvC,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAA;IAOxD,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAA;CACtB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,WAAW,EAAE,MAAM,QAAQ,CAAA;IAC3B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,eAAe,CACzB,OAAO,GAAG,SAAS,EACnB,SAAS,SAAS,YAAY,GAAG,QAAQ,IACvC;KACD,MAAM,IAAI,YAAY,CAAC,OAAO,CAAC,GAAG;QACjC,uCAAuC;QACvC,YAAY,EAAE,MAAM,CAAA;QACpB,iFAAiF;QACjF,IAAI,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAA;KAC/C;CACF,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAA;AAExB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,kBAAkB,CAC5B,OAAO,GAAG,SAAS,EACnB,SAAS,SAAS,YAAY,GAAG,QAAQ,IACvC,QAAQ,GAAG,cAAc,GAAG,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,SAAS,CAAA;AAM/E;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAC7B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,eAAe,GAAG,OAAO,CACzB,SAAQ,IAAI,CACZ,kBAAkB,CAChB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC3C,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC5C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EACvC,eAAe,CAChB,EACD,YAAY,CACb;IACC,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,EAAE,kBAAkB,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAA;IAC5D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAAe,CAAC,EAAE,CAChB,KAAK,EAAE,aAAa,CAClB,uBAAuB,CACrB,SAAS,CAAC,qBAAqB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EACjD,OAAO,CACR,CAAC,SAAS,CAAC,CACb,EACD,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,KAC/C,IAAI,CAAA;CACV;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAC/B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,eAAe,GAAG,OAAO,IACvB,IAAI,CACN,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,CAAC,EAC3D,WAAW,CACZ,CAAA;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB,CAClC,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ,EACzC,eAAe,GAAG,OAAO,CACzB,SAAQ,IAAI,CACZ,kBAAkB,CAChB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC3C,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC5C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EACvC,eAAe,CAChB,EACD,YAAY,CACb;IACC;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,kBAAkB,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAA;IAC5D;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAChB,KAAK,EAAE,aAAa,CAClB,uBAAuB,CACrB,SAAS,CAAC,qBAAqB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EACjD,OAAO,CACR,CAAC,SAAS,CAAC,CACb,EACD,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,KAC/C,IAAI,CAAA;CACV;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAC7B,OAAO,GAAG,SAAS,EACnB,MAAM,SAAS,YAAY,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,EAC5D,SAAS,SAAS,YAAY,GAAG,QAAQ;IAEzC;;;;;;;;;OASG;IACH,WAAW,EAAE,CAAC,eAAe,GAAG,OAAO,EACrC,OAAO,CAAC,EAAE,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,CAAC,KACvE,iBAAiB,CACpB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC3C,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAC5C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EACvC,eAAe,CAChB,CAAA;IAED;;;;;OAKG;IACH,OAAO,EAAE,CACP,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,KAC1C,OAAO,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAA;CAC1D"}

package/dist/types.js

@@ -1,5 +0,0 @@
-/**
- * Shared type definitions for query factories (createQuery, createSuspenseQuery, etc.)
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/utils.d.ts

@@ -1,207 +0,0 @@
-/**
- * Shared internal utilities for the query and mutation hooks and factories.
- */
-import type { QueryClient, QueryKey } from "@tanstack/react-query";
-import type { CallConfig } from "@icp-sdk/core/agent";
-import type { ClientManager, Reactor, ReactorQueryData, TransformKey } from "@ic-reactor/core";
-import type { InvalidationTarget, QueryCacheControls, QueryFactoryMethods } from "./types.js";
-/**
- * Keep `queryClient` mounted while the calling component is.
- *
- * `QueryClient.mount()` is what subscribes a client to TanStack's focus and
- * online managers. Those subscriptions refetch stale queries on window focus
- * and on reconnect, resume a fetch that started offline or a retry that paused
- * while the tab was hidden, and resume mutations sent offline.
- * `QueryClientProvider` normally calls it, but every hook here binds to its
- * reactor's own client rather than the context one, and the setup guide calls
- * the provider optional. Without one, nothing mounted the client: a query that
- * started offline stayed `paused` after the connection came back, a mutation
- * sent offline stayed pending, and `refetchOnWindowFocus` and
- * `refetchOnReconnect` never fired.
- *
- * `mount()` and `unmount()` are reference-counted, so this composes with a
- * provider mounting the same client and with any number of hooks. It runs in
- * an effect, like the provider's, so a server render never subscribes.
- *
- * A reactor stand-in without a `queryClient` (a test double, say) makes the
- * TanStack hooks fall back to the context client, which its provider mounts,
- * so there is nothing to do for one.
- */
-export declare function useMountQueryClient(queryClient: QueryClient | undefined): void;
-/**
- * Keep `queryClient` mounted while a suspense hook waits on the promise it
- * threw. Call it from a `catch` around the TanStack suspense hook, then
- * rethrow. The `try` only lets the hook see the promise: it is rethrown
- * untouched, so React discards the render as before and hook order is kept.
- *
- * A suspense hook throws its fetch promise before its component commits, so
- * the effect in {@link useMountQueryClient} cannot run until that promise
- * settles. A fetch that started offline, or whose retry is waiting for a hidden
- * tab to come back, settles only once a mounted client hears the connection or
- * the focus return. Without a provider nothing had mounted the client, so the
- * Suspense fallback stayed up after reconnecting.
- *
- * The mount taken here is released when the promise settles, whether or not
- * anything ever commits, so it stays balanced: each suspended render, a
- * StrictMode double render or a retry included, takes and releases its own
- * reference. Once the component commits, its effect holds the client like any
- * other hook's. A tree discarded while suspended lets go once its fetch
- * finishes, which it does on reconnect, as it would under a mounted provider.
- * A server render never subscribes.
- */
-export declare function mountWhileSuspended(queryClient: QueryClient | undefined, thrown: unknown): void;
-/**
- * Internal query-key segment used to distinguish per-call factory args
- * from the base query key. Not part of the public API.
- */
-export declare const FACTORY_KEY_ARGS_QUERY_KEY = "__ic_reactor_factory_key_args";
-/**
- * Internal query-key segment that ends the key of a query waiting on
- * `skipToken`. Not part of the public API.
- */
-export declare const SKIPPED_QUERY_KEY = "__ic_reactor_skipped";
-/**
- * The key of a query whose args are `skipToken`: `prefix`, the method's key
- * that every key its args give extends, and then a segment no call's key has.
- *
- * It used to be the bare prefix, which is also the key of a query of the same
- * method made without args, as a method with no parameters is called. The
- * skipped query then showed that query's data though its own args were not
- * known. And TanStack Query refetches an entry with the options of whichever
- * of its observers rendered last, so an invalidation, including the sweep a
- * sign-in or sign-out runs, could find `skipToken` in place of the query
- * function: the refetch failed with "Missing queryFn" and the other query
- * kept the previous caller's answer.
- *
- * `kind` keeps a waiting list apart from a waiting query of the same method,
- * since TanStack Query does not share an entry between `useQuery` and
- * `useInfiniteQuery`.
- */
-export declare function skippedQueryKey(prefix: QueryKey, kind: "query" | "infinite"): QueryKey;
-/**
- * The call config an infinite query's function fetches with: the caller's,
- * aimed at the canister its query key names unless the caller named one.
- *
- * The key is built from the reactor's canister when the query is set up, but
- * the query function reached `callMethod`, which reads `reactor.canisterId`
- * again whenever it runs. After a `setCanisterId`, a retry or a refetch by an
- * observer that had not re-rendered then fetched the new canister's pages and
- * cached them under the old canister's key. `generateQueryKey` always roots a
- * key at the canister it resolved, so the key says where its pages come from.
- * `Reactor.getQueryOptions` pins its query function the same way.
- */
-export declare function callConfigForKey(queryKey: QueryKey, callConfig: CallConfig | undefined): CallConfig | undefined;
-/** Convert a direct reactor result into a value TanStack Query can cache. */
-export declare const normalizeQueryData: <T>(value: T) => ReactorQueryData<T>;
-/** Config options that decide how a query's function runs. */
-declare const FETCH_OPTION_KEYS: readonly ["networkMode", "retry", "retryDelay", "meta"];
-type FetchOptionKey = (typeof FETCH_OPTION_KEYS)[number];
-/**
- * The part of a factory config that `fetch()` and `prefetch()` pass on.
- *
- * A factory's hook hands its whole config to TanStack Query, but the
- * imperative path used to pass only the key and query function. So a config's
- * `networkMode: "always"` let the hook fetch while `fetch()` stayed paused
- * offline, its `retry` retried in the hook and not in a loader, and its `meta`
- * never reached the QueryCache callbacks for a `fetch()` failure. These four
- * say how the query function runs, so they now apply to both paths.
- *
- * Options that decide what the cache keeps (`gcTime`, `initialData`) or how an
- * observer renders (`select`, `placeholderData`, `enabled`, …) stay with the
- * hook. Unset options are left out rather than passed as `undefined`, which
- * would override the QueryClient's own defaults.
- */
-export declare function pickFetchOptions<Config extends object>(config: Config): Partial<Pick<Config, Extract<keyof Config, FetchOptionKey>>>;
-/**
- * The `retry` entry of a query's options: the query's own `retry` when it sets
- * one, otherwise the reactor's default for its method, and no entry when
- * neither is set, so the QueryClient's defaults apply.
- *
- * The default is `Reactor.getQueryRetry`'s: `undefined` for a query method,
- * and for an update method a retry of only the failures that prove the
- * canister never ran the call, since each attempt runs the update again.
- * Spread this after the caller's options. An update method's default then also
- * replaces a `retry: undefined` spread in from them, which would otherwise
- * select TanStack Query's own three retries.
- */
-export declare function retryOption<TRetry, TDefault>(ownRetry: TRetry | undefined, defaultRetry: TDefault | undefined): {
-    retry?: TRetry | TDefault;
-};
-/**
- * Merge a base query key, optional per-call query key, and optional key-args
- * into a single query key array.
- *
- * Used by createInfiniteQueryFactory and createSuspenseInfiniteQueryFactory to
- * ensure each unique set of factory args produces a distinct cache entry.
- */
-export declare function mergeFactoryQueryKey(baseQueryKey?: QueryKey, callQueryKey?: QueryKey, keyArgs?: unknown): QueryKey | undefined;
-/**
- * Build a chained select that applies the config-level select (if any) and then
- * the hook-level select (if any).
- *
- * Returns the caller's own function untouched when only one of the two is
- * present, and `undefined` when neither is — allocating a wrapper only for the
- * genuinely chained case. Identity matters here: `QueryObserver` memoizes a
- * select result on `options.select === previousSelectFn`, so a wrapper rebuilt
- * on every render defeats that check. The select then re-runs each render, and
- * for a select returning a non-plain value (a `Map`, a `Date`, a `Principal`)
- * `replaceEqualDeep` cannot structurally share the result either, so `data`
- * gets a fresh reference every render and a `useEffect([data])` that sets state
- * becomes an unbounded loop.
- *
- * Callers should still memoize the result, since the chained case allocates.
- */
-export declare function buildChainedSelect<TData, TSelected, TFinal = TSelected>(configSelect: ((data: TData) => TSelected) | undefined, hookSelect: ((data: TSelected) => TFinal) | undefined): ((rawData: TData) => TSelected | TFinal) | undefined;
-/**
- * Smallest useful LRU: a `Map` already iterates in insertion order, so
- * re-inserting on read is enough to track recency.
- *
- * Eviction is safe — it costs memoization, never correctness. A query object is
- * a closure over the reactor and config, so one rebuilt after eviction behaves
- * identically; only its reference identity differs.
- */
-export declare function createBoundedCache<V>(limit?: number): {
-    get(key: string): V | undefined;
-    set(key: string, value: V): void;
-    readonly size: number;
-};
-/**
- * Invalidate every entry of a mutation's `invalidateQueries` in parallel, on
- * behalf of `reactor`, the mutation's own. It resolves once every active
- * query they matched has refetched; a refetch that fails does not reject it,
- * so it cannot turn an update that already ran into a failure.
- *
- * An entry is a query key, a query object or query factory (anything with a
- * `getQueryKey()`), or a `{ functionName, args? }` descriptor, which is keyed
- * by `reactor.generateQueryKey` at the canister the mutation was sent to:
- * the one its `callConfig.canisterId` names, else the reactor's. `undefined`
- * entries are skipped.
- */
-export declare function invalidateTargets<Service, Transform extends TransformKey>(reactor: Reactor<Service, Transform>, targets: readonly InvalidationTarget<Service, Transform>[] | undefined, callConfig?: CallConfig): Promise<void>;
-/**
- * Give an args-late query factory function its {@link QueryFactoryMethods}.
- *
- * `getQueryKey` builds the prefix every query of the factory shares, and is
- * called each time so that it follows a `setCanisterId`.
- */
-export declare function withQueryFactoryMethods<Factory extends object>(factory: Factory, reactor: {
-    readonly queryClient: QueryClient;
-}, getQueryKey: () => QueryKey): Factory & QueryFactoryMethods;
-/** What {@link queryCacheControls} reads from a reactor. */
-interface CacheOwner {
-    readonly queryClient: QueryClient;
-    readonly clientManager: Pick<ClientManager, "identity">;
-}
-/**
- * The {@link QueryCacheControls} of a query object: `cancel`, `reset` and
- * `optimisticUpdate` on its own entry of the reactor's QueryClient.
- *
- * They match the key exactly. A query object's key is also the prefix of
- * other entries (a query without args prefixes every args instance of its
- * method), and cancelling or resetting those would reach queries this object
- * does not own. `getQueryKey` is called each time, so the controls follow a
- * `setCanisterId`.
- */
-export declare function queryCacheControls<TQueryFnData>(reactor: CacheOwner, getQueryKey: () => QueryKey): QueryCacheControls<TQueryFnData>;
-export {};
-//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/dist/utils.js

@@ -1,405 +0,0 @@
-/**
- * Shared internal utilities for the query and mutation hooks and factories.
- */
-import { useEffect } from "react";
-import { generateKey } from "@ic-reactor/core";
-/**
- * Keep `queryClient` mounted while the calling component is.
- *
- * `QueryClient.mount()` is what subscribes a client to TanStack's focus and
- * online managers. Those subscriptions refetch stale queries on window focus
- * and on reconnect, resume a fetch that started offline or a retry that paused
- * while the tab was hidden, and resume mutations sent offline.
- * `QueryClientProvider` normally calls it, but every hook here binds to its
- * reactor's own client rather than the context one, and the setup guide calls
- * the provider optional. Without one, nothing mounted the client: a query that
- * started offline stayed `paused` after the connection came back, a mutation
- * sent offline stayed pending, and `refetchOnWindowFocus` and
- * `refetchOnReconnect` never fired.
- *
- * `mount()` and `unmount()` are reference-counted, so this composes with a
- * provider mounting the same client and with any number of hooks. It runs in
- * an effect, like the provider's, so a server render never subscribes.
- *
- * A reactor stand-in without a `queryClient` (a test double, say) makes the
- * TanStack hooks fall back to the context client, which its provider mounts,
- * so there is nothing to do for one.
- */
-export function useMountQueryClient(queryClient) {
-    useEffect(() => {
-        if (!queryClient)
-            return;
-        queryClient.mount();
-        return () => queryClient.unmount();
-    }, [queryClient]);
-}
-const isThenable = (value) => typeof value?.then === "function";
-/**
- * Keep `queryClient` mounted while a suspense hook waits on the promise it
- * threw. Call it from a `catch` around the TanStack suspense hook, then
- * rethrow. The `try` only lets the hook see the promise: it is rethrown
- * untouched, so React discards the render as before and hook order is kept.
- *
- * A suspense hook throws its fetch promise before its component commits, so
- * the effect in {@link useMountQueryClient} cannot run until that promise
- * settles. A fetch that started offline, or whose retry is waiting for a hidden
- * tab to come back, settles only once a mounted client hears the connection or
- * the focus return. Without a provider nothing had mounted the client, so the
- * Suspense fallback stayed up after reconnecting.
- *
- * The mount taken here is released when the promise settles, whether or not
- * anything ever commits, so it stays balanced: each suspended render, a
- * StrictMode double render or a retry included, takes and releases its own
- * reference. Once the component commits, its effect holds the client like any
- * other hook's. A tree discarded while suspended lets go once its fetch
- * finishes, which it does on reconnect, as it would under a mounted provider.
- * A server render never subscribes.
- */
-export function mountWhileSuspended(queryClient, thrown) {
-    if (!queryClient || typeof window === "undefined" || !isThenable(thrown)) {
-        return;
-    }
-    queryClient.mount();
-    const release = () => queryClient.unmount();
-    void thrown.then(release, release);
-}
-/**
- * Internal query-key segment used to distinguish per-call factory args
- * from the base query key. Not part of the public API.
- */
-export const FACTORY_KEY_ARGS_QUERY_KEY = "__ic_reactor_factory_key_args";
-/**
- * Internal query-key segment that ends the key of a query waiting on
- * `skipToken`. Not part of the public API.
- */
-export const SKIPPED_QUERY_KEY = "__ic_reactor_skipped";
-/**
- * The key of a query whose args are `skipToken`: `prefix`, the method's key
- * that every key its args give extends, and then a segment no call's key has.
- *
- * It used to be the bare prefix, which is also the key of a query of the same
- * method made without args, as a method with no parameters is called. The
- * skipped query then showed that query's data though its own args were not
- * known. And TanStack Query refetches an entry with the options of whichever
- * of its observers rendered last, so an invalidation, including the sweep a
- * sign-in or sign-out runs, could find `skipToken` in place of the query
- * function: the refetch failed with "Missing queryFn" and the other query
- * kept the previous caller's answer.
- *
- * `kind` keeps a waiting list apart from a waiting query of the same method,
- * since TanStack Query does not share an entry between `useQuery` and
- * `useInfiniteQuery`.
- */
-export function skippedQueryKey(prefix, kind) {
-    return [...prefix, { [SKIPPED_QUERY_KEY]: kind }];
-}
-/**
- * The call config an infinite query's function fetches with: the caller's,
- * aimed at the canister its query key names unless the caller named one.
- *
- * The key is built from the reactor's canister when the query is set up, but
- * the query function reached `callMethod`, which reads `reactor.canisterId`
- * again whenever it runs. After a `setCanisterId`, a retry or a refetch by an
- * observer that had not re-rendered then fetched the new canister's pages and
- * cached them under the old canister's key. `generateQueryKey` always roots a
- * key at the canister it resolved, so the key says where its pages come from.
- * `Reactor.getQueryOptions` pins its query function the same way.
- */
-export function callConfigForKey(queryKey, callConfig) {
-    const keyedCanister = queryKey[0];
-    if (callConfig?.canisterId || typeof keyedCanister !== "string") {
-        return callConfig;
-    }
-    return { ...callConfig, canisterId: keyedCanister };
-}
-/** Convert a direct reactor result into a value TanStack Query can cache. */
-export const normalizeQueryData = (value) => (value === undefined ? null : value);
-/** Config options that decide how a query's function runs. */
-const FETCH_OPTION_KEYS = [
-    "networkMode",
-    "retry",
-    "retryDelay",
-    "meta",
-];
-/**
- * The part of a factory config that `fetch()` and `prefetch()` pass on.
- *
- * A factory's hook hands its whole config to TanStack Query, but the
- * imperative path used to pass only the key and query function. So a config's
- * `networkMode: "always"` let the hook fetch while `fetch()` stayed paused
- * offline, its `retry` retried in the hook and not in a loader, and its `meta`
- * never reached the QueryCache callbacks for a `fetch()` failure. These four
- * say how the query function runs, so they now apply to both paths.
- *
- * Options that decide what the cache keeps (`gcTime`, `initialData`) or how an
- * observer renders (`select`, `placeholderData`, `enabled`, …) stay with the
- * hook. Unset options are left out rather than passed as `undefined`, which
- * would override the QueryClient's own defaults.
- */
-export function pickFetchOptions(config) {
-    const picked = {};
-    for (const key of FETCH_OPTION_KEYS) {
-        const value = config[key];
-        if (value !== undefined)
-            picked[key] = value;
-    }
-    return picked;
-}
-/**
- * The `retry` entry of a query's options: the query's own `retry` when it sets
- * one, otherwise the reactor's default for its method, and no entry when
- * neither is set, so the QueryClient's defaults apply.
- *
- * The default is `Reactor.getQueryRetry`'s: `undefined` for a query method,
- * and for an update method a retry of only the failures that prove the
- * canister never ran the call, since each attempt runs the update again.
- * Spread this after the caller's options. An update method's default then also
- * replaces a `retry: undefined` spread in from them, which would otherwise
- * select TanStack Query's own three retries.
- */
-export function retryOption(ownRetry, defaultRetry) {
-    const retry = ownRetry ?? defaultRetry;
-    return retry === undefined ? {} : { retry };
-}
-/**
- * Merge a base query key, optional per-call query key, and optional key-args
- * into a single query key array.
- *
- * Used by createInfiniteQueryFactory and createSuspenseInfiniteQueryFactory to
- * ensure each unique set of factory args produces a distinct cache entry.
- */
-export function mergeFactoryQueryKey(baseQueryKey, callQueryKey, keyArgs) {
-    const merged = [];
-    if (baseQueryKey)
-        merged.push(...baseQueryKey);
-    if (callQueryKey)
-        merged.push(...callQueryKey);
-    if (keyArgs !== undefined) {
-        // Serialize keyArgs through generateKey so BigInt values (and other
-        // non-JSON-serializable Candid types such as Principal) are safely
-        // converted to strings before React Query hashes the key.
-        const safeKeyArgs = generateKey(Array.isArray(keyArgs) ? keyArgs : [keyArgs]);
-        merged.push({ [FACTORY_KEY_ARGS_QUERY_KEY]: safeKeyArgs });
-    }
-    return merged.length > 0 ? merged : undefined;
-}
-/**
- * Build a chained select that applies the config-level select (if any) and then
- * the hook-level select (if any).
- *
- * Returns the caller's own function untouched when only one of the two is
- * present, and `undefined` when neither is — allocating a wrapper only for the
- * genuinely chained case. Identity matters here: `QueryObserver` memoizes a
- * select result on `options.select === previousSelectFn`, so a wrapper rebuilt
- * on every render defeats that check. The select then re-runs each render, and
- * for a select returning a non-plain value (a `Map`, a `Date`, a `Principal`)
- * `replaceEqualDeep` cannot structurally share the result either, so `data`
- * gets a fresh reference every render and a `useEffect([data])` that sets state
- * becomes an unbounded loop.
- *
- * Callers should still memoize the result, since the chained case allocates.
- */
-export function buildChainedSelect(configSelect, hookSelect) {
-    if (!configSelect) {
-        // `hookSelect` receives the raw data when there is no config-level select,
-        // matching the previous behaviour.
-        return hookSelect;
-    }
-    if (!hookSelect)
-        return configSelect;
-    return (rawData) => hookSelect(configSelect(rawData));
-}
-/**
- * How many memoized query objects an args-late factory keeps.
- *
- * The memo exists so `getBalance(sameArgs)` returns the same object twice; it
- * was unbounded, so an open-ended argument space — a per-principal balance in a
- * long-lived SPA, a search-as-you-type filter, a cursor-keyed list — grew it
- * forever (measured at ~2.9 kB per entry, 55.8 MB for 20k). A few hundred
- * covers any realistic working set while capping the worst case.
- */
-const FACTORY_CACHE_LIMIT = 256;
-/**
- * Smallest useful LRU: a `Map` already iterates in insertion order, so
- * re-inserting on read is enough to track recency.
- *
- * Eviction is safe — it costs memoization, never correctness. A query object is
- * a closure over the reactor and config, so one rebuilt after eviction behaves
- * identically; only its reference identity differs.
- */
-export function createBoundedCache(limit = FACTORY_CACHE_LIMIT) {
-    const entries = new Map();
-    return {
-        get(key) {
-            const value = entries.get(key);
-            if (value === undefined)
-                return undefined;
-            // Touch: move to the most-recent end.
-            entries.delete(key);
-            entries.set(key, value);
-            return value;
-        },
-        set(key, value) {
-            if (entries.has(key))
-                entries.delete(key);
-            else if (entries.size >= limit) {
-                const oldest = entries.keys().next().value;
-                if (oldest !== undefined)
-                    entries.delete(oldest);
-            }
-            entries.set(key, value);
-        },
-        get size() {
-            return entries.size;
-        },
-    };
-}
-const isQueryKeySource = (value) => typeof value.getQueryKey === "function";
-/**
- * Invalidate one `invalidateQueries` entry; see {@link invalidateTargets}.
- */
-function invalidateTarget(reactor, target, canisterId) {
-    // React Query reads `{ queryKey: undefined }` as "match everything", so an
-    // absent entry would invalidate every query in the client, the app's
-    // unrelated non-canister ones included. `null` only comes from untyped code
-    // and would do the same.
-    if (target == null)
-        return Promise.resolve();
-    if (Array.isArray(target)) {
-        return reactor.queryClient.invalidateQueries({ queryKey: target });
-    }
-    if (isQueryKeySource(target)) {
-        // A query object or factory invalidates on its own reactor's client, which
-        // is not this reactor's when each reactor has a QueryClient of its own.
-        return target.invalidate
-            ? target.invalidate()
-            : reactor.queryClient.invalidateQueries({
-                queryKey: target.getQueryKey(),
-            });
-    }
-    // A `{ functionName, args? }` descriptor. Its key is built now rather than
-    // when the mutation was set up, so it follows a `setCanisterId`.
-    const { functionName, args } = target;
-    // `args: []`, all that a method without parameters takes, names the same
-    // queries as no args. Keyed as given, it adds an args segment that a query
-    // made without args lacks, and would match none of those.
-    const hasArgs = args?.length;
-    return reactor.queryClient.invalidateQueries({
-        // At the canister the mutation was sent to, whose queries it changed.
-        // Only the canister is taken from its `callConfig`: an agent or effective
-        // target segment would narrow the prefix to the queries sent the same
-        // way, while the canister's state changed for every caller.
-        queryKey: reactor.generateQueryKey({ functionName, args: hasArgs ? args : undefined }, canisterId ? { canisterId } : undefined),
-    });
-}
-/**
- * Invalidate every entry of a mutation's `invalidateQueries` in parallel, on
- * behalf of `reactor`, the mutation's own. It resolves once every active
- * query they matched has refetched; a refetch that fails does not reject it,
- * so it cannot turn an update that already ran into a failure.
- *
- * An entry is a query key, a query object or query factory (anything with a
- * `getQueryKey()`), or a `{ functionName, args? }` descriptor, which is keyed
- * by `reactor.generateQueryKey` at the canister the mutation was sent to:
- * the one its `callConfig.canisterId` names, else the reactor's. `undefined`
- * entries are skipped.
- */
-export async function invalidateTargets(reactor, targets, callConfig) {
-    if (!targets || targets.length === 0)
-        return;
-    await Promise.all(targets.map((target) => invalidateTarget(reactor, target, callConfig?.canisterId)));
-}
-/**
- * Give an args-late query factory function its {@link QueryFactoryMethods}.
- *
- * `getQueryKey` builds the prefix every query of the factory shares, and is
- * called each time so that it follows a `setCanisterId`.
- */
-export function withQueryFactoryMethods(factory, reactor, getQueryKey) {
-    const methods = {
-        getQueryKey,
-        invalidate: () => reactor.queryClient.invalidateQueries({ queryKey: getQueryKey() }),
-    };
-    return Object.assign(factory, methods);
-}
-/** The rollback of an optimistic update that wrote nothing. */
-const NOTHING_TO_ROLL_BACK = { rollback: () => { } };
-/**
- * The principal whose answers the reactor's cache holds: the one installed on
- * the manager's agent, `undefined` before one is.
- *
- * Query keys carry no principal. `ClientManager.updateAgent` sweeps the cache
- * instead when another principal signs in, removing inactive entries and
- * refetching active ones, so a value read from the cache is this principal's
- * only while it stays installed.
- */
-const cachedPrincipal = (reactor) => reactor.clientManager.identity?.getPrincipal().toText();
-/**
- * The {@link QueryCacheControls} of a query object: `cancel`, `reset` and
- * `optimisticUpdate` on its own entry of the reactor's QueryClient.
- *
- * They match the key exactly. A query object's key is also the prefix of
- * other entries (a query without args prefixes every args instance of its
- * method), and cancelling or resetting those would reach queries this object
- * does not own. `getQueryKey` is called each time, so the controls follow a
- * `setCanisterId`.
- */
-export function queryCacheControls(reactor, getQueryKey) {
-    return {
-        cancel: () => reactor.queryClient.cancelQueries({
-            queryKey: getQueryKey(),
-            exact: true,
-        }),
-        reset: () => reactor.queryClient.resetQueries({
-            queryKey: getQueryKey(),
-            exact: true,
-        }),
-        optimisticUpdate: async (updater) => {
-            const { queryClient } = reactor;
-            const queryKey = getQueryKey();
-            // Nothing cached means nothing on screen to update. Cancelling the
-            // entry's first fetch would also leave it pending with no data.
-            if (queryClient.getQueryData(queryKey) === undefined) {
-                return NOTHING_TO_ROLL_BACK;
-            }
-            const principal = cachedPrincipal(reactor);
-            // A fetch in flight would otherwise land after the write below with the
-            // canister's answer from before the mutation. Cancelling reverts the
-            // entry to what it held before that fetch, so it is read afterwards.
-            await queryClient.cancelQueries({ queryKey, exact: true });
-            // A sign-in or sign-out while that ran left the previous principal's
-            // value in the entry until the sweep's refetch lands. An update built
-            // on it would show that value to the principal signed in now.
-            if (cachedPrincipal(reactor) !== principal)
-                return NOTHING_TO_ROLL_BACK;
-            const snapshot = queryClient.getQueryState(queryKey);
-            if (snapshot?.data === undefined)
-                return NOTHING_TO_ROLL_BACK;
-            const { data: previous, dataUpdatedAt, isInvalidated } = snapshot;
-            queryClient.setQueryData(queryKey, updater(previous));
-            return {
-                rollback: () => {
-                    // After a switch to another principal, `previous` is the previous
-                    // principal's value, which the sweep has removed or is refetching.
-                    // Written back, it would be served to the one signed in now.
-                    if (cachedPrincipal(reactor) !== principal)
-                        return;
-                    // With its own timestamp: written back as new, a value from before
-                    // the mutation would look freshly fetched and skip the refetches
-                    // its age calls for.
-                    queryClient.setQueryData(queryKey, previous, {
-                        updatedAt: dataUpdatedAt,
-                    });
-                    // The write clears the invalidated mark too, and the fetch the
-                    // update cancelled was often the refetch an invalidation started.
-                    // Marked again, the value reads as outdated as it was, and a
-                    // mounted query refetches it.
-                    if (isInvalidated) {
-                        void queryClient.invalidateQueries({ queryKey, exact: true });
-                    }
-                },
-            };
-        },
-    };
-}
-//# sourceMappingURL=utils.js.map