@ensforge/react 0.0.0 → 0.1.1

package/dist/hooks/registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/hooks/registration.ts"],"mappings":";;;;;;;cAuBa,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC5E,4BAAyB;;;;;;;;;;;;;;;;;;;;;;;UAA+C;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACxE,oCAAiC;;;;;;;;;;;;;;;;;;;;;;;UAE7C;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACY,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC5E,uBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC9D,+BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC9E,kBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACpD,0BAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACpE,6BAA0B;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACvE,qCAAkC;;;;;;;;;;;;;;;UAE9C;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACY,4BAAyB;;;;;UAAgD;;;;;GAAA,cAAA,eAAA,mCAAA;cACzE,oCAAiC;;;;;UAE7C;;;;;GAAA,cAAA,uBAAA;cAEY,yBAAsB,UAAtB,4CAAsB,wDAAA,8CAAA,gBAAA,2CAAA,wDAAA,8CAAA;cACtB,2BAAwB,UAAxB,4CAAwB,0DAAA,8CAAA,gBAAA,2CAAA,0DAAA,8CAAA;cACxB,gBAAa,UAAb,4CAAa,+CAAA,8CAAA,gBAAA,2CAAA,+CAAA,8CAAA;cACb,0BAAuB,UAAvB,4CAAuB,yDAAA,8CAAA,gBAAA,2CAAA,yDAAA,8CAAA;cACvB,kBAAe,UAAf,4CAAe,iDAAA,6CAAA,gBAAA,2CAAA,iDAAA,6CAAA;cACf,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,eAAY,UAAZ,4CAAY,8CAAA,0CAAA,gBAAA,2CAAA,8CAAA,0CAAA;cACZ,gBAAa,UAAb,4CAAa,+CAAA,2CAAA,gBAAA,2CAAA,+CAAA,2CAAA"}
+{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/hooks/registration.ts"],"mappings":";;;;;;;cAuBa,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cAC5E,4BAAyB;;;;;;;;;;;;;;;;;;;;;;;UAA+C;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cACxE,oCAAiC;;;;;;;;;;;;;;;;;;;;;;;UAE7C;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cACY,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cAC5E,uBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cAC9D,+BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cAC9E,kBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cACpD,0BAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cACpE,6BAA0B;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cACvE,qCAAkC;;;;;;;;;;;;;;;UAE9C;;;;;;;;;;;;;;;4BAAA,0BAAA,YAAA,sBAAA;cACY,4BAAyB;;;;;UAAgD;;;;;4BAAA,0BAAA,YAAA,cAAA,iCAAA;cACzE,oCAAiC;;;;;UAE7C;;;;;4BAAA,0BAAA,YAAA,sBAAA;cAEY,yBAAsB,UAAtB,4CAAsB,wDAAA,8CAAA,gBAAA,2CAAA,wDAAA,8CAAA;cACtB,2BAAwB,UAAxB,4CAAwB,0DAAA,8CAAA,gBAAA,2CAAA,0DAAA,8CAAA;cACxB,gBAAa,UAAb,4CAAa,+CAAA,8CAAA,gBAAA,2CAAA,+CAAA,8CAAA;cACb,0BAAuB,UAAvB,4CAAuB,yDAAA,8CAAA,gBAAA,2CAAA,yDAAA,8CAAA;cACvB,kBAAe,UAAf,4CAAe,iDAAA,6CAAA,gBAAA,2CAAA,iDAAA,6CAAA;cACf,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,eAAY,UAAZ,4CAAY,8CAAA,0CAAA,gBAAA,2CAAA,8CAAA,0CAAA;cACZ,gBAAa,UAAb,4CAAa,+CAAA,2CAAA,gBAAA,2CAAA,+CAAA,2CAAA"}

package/dist/hooks/resolution.d.ts

@@ -1,11 +1,11 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/resolution.d.ts
-declare const useAlias: <Selected = {
+declare const useAlias: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -16,7 +16,7 @@ declare const useAlias: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetAliasParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetAliasParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -27,8 +27,8 @@ declare const useAlias: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetAliasError>;
-declare const useAliasSuspense: <Selected = {
+}, import("@ensforge/core").GetAliasError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetAliasError>;
+declare const useAliasSuspense: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -39,7 +39,7 @@ declare const useAliasSuspense: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetAliasParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetAliasParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -50,10 +50,10 @@ declare const useAliasSuspense: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolver: <Selected = import("@ensforge/core").GetResolverResult>(input: UseEnsQueryParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetResolverError>;
-declare const useResolverSuspense: <Selected = import("@ensforge/core").GetResolverResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolverVersion: <Selected = {
+}, import("@ensforge/core").GetAliasError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolver: <Mapped = import("@ensforge/core").GetResolverResult>(input: UseEnsAtomParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetResolverError>;
+declare const useResolverSuspense: <Mapped = import("@ensforge/core").GetResolverResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolverVersion: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -63,7 +63,7 @@ declare const useResolverVersion: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetResolverVersionParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -73,8 +73,8 @@ declare const useResolverVersion: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetResolverError>;
-declare const useResolverVersionSuspense: <Selected = {
+}, import("@ensforge/core").GetResolverError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetResolverError>;
+declare const useResolverVersionSuspense: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -84,7 +84,7 @@ declare const useResolverVersionSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetResolverVersionParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -94,39 +94,39 @@ declare const useResolverVersionSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const usePredictResolverAddress: <Selected = `0x${string}`>(input: UseEnsQueryParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").WriteError>;
-declare const usePredictResolverAddressSuspense: <Selected = `0x${string}`>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolve: <Selected = {
+}, import("@ensforge/core").GetResolverError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const usePredictResolverAddress: <Mapped = `0x${string}`>(input: UseEnsAtomParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").WriteError>;
+declare const usePredictResolverAddressSuspense: <Mapped = `0x${string}`>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolve: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveParameters, {
+} | null>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveSuspense: <Selected = {
+} | null, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveSuspense: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveParameters, {
+} | null>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolveBatch: <Selected = import("@ensforge/core").ResolveBatchResult>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveBatchSuspense: <Selected = import("@ensforge/core").ResolveBatchResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolveWithResolver: <Selected = {
+} | null, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolveBatch: <Mapped = import("@ensforge/core").ResolveBatchResult>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveBatchSuspense: <Mapped = import("@ensforge/core").ResolveBatchResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolveWithResolver: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveWithResolverParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveWithResolverSuspense: <Selected = {
+}, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveWithResolverSuspense: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveWithResolverParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
+}, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useCreateResolver: (options?: EnsMutationOptions<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>;
 declare const useGetOrCreateResolver: (options?: EnsMutationOptions<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>;
 declare const useSetResolver: (options?: EnsMutationOptions<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

package/dist/hooks/resolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/hooks/resolution.ts"],"mappings":";;;;;;;cAoBa,WAAQ;;;;;;;;;;;UAA8B;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACtC,mBAAgB;;;;;;;;;;;UAAsC;;;;;;;;;;;GAAA,cAAA,uBAAA;cACtD,cAAW,oCAAA,mBAAA,OAAA,+CAAA,gDAAA,mBAAA,cAAA,eAAA,mCAAA;cACX,sBAAmB,oCAAA,mBAAA,OAAA,uDAAA,gDAAA,mBAAA,cAAA,uBAAA;cACnB,qBAAkB;;;;;;;;;;UAAwC;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC1D,6BAA0B;;;;;;;;;;UAAgD;;;;;;;;;;GAAA,cAAA,uBAAA;cAC1E,4BAAyB,0BAAA,OAAA,+CAAA,yCAAA,cAAA,eAAA,mCAAA;cACzB,oCAAiC,0BAAA,OAAA,uDAAA,yCAAA,cAAA,uBAAA;cACjC,aAAU;;;iBAA6B;;;UAAA,cAAA,eAAA,mCAAA;cACvC,qBAAkB;;;iBAAqC;;;UAAA,cAAA,uBAAA;cACvD,kBAAe,oCAAA,oBAAA,OAAA,+CAAA,iDAAA,oBAAA,cAAA,eAAA,mCAAA;cACf,0BAAuB,oCAAA,oBAAA,OAAA,uDAAA,iDAAA,oBAAA,cAAA,uBAAA;cACvB,yBAAsB;;;UAAyC;;;GAAA,cAAA,eAAA,mCAAA;cAC/D,iCAA8B;;;UAAiD;;;GAAA,cAAA,uBAAA;cAE/E,oBAAiB,UAAjB,4CAAiB,mDAAA,+CAAA,gBAAA,2CAAA,mDAAA,+CAAA;cACjB,yBAAsB,UAAtB,4CAAsB,wDAAA,oDAAA,gBAAA,2CAAA,wDAAA,oDAAA;cACtB,iBAAc,UAAd,4CAAc,gDAAA,8CAAA,gBAAA,2CAAA,gDAAA,8CAAA;cACd,2BAAwB,UAAxB,4CAAwB,0DAAA,wDAAA,gBAAA,2CAAA,0DAAA,wDAAA;cACxB,qBAAkB,UAAlB,4CAAkB,oDAAA,gDAAA,gBAAA,2CAAA,oDAAA,gDAAA"}
+{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/hooks/resolution.ts"],"mappings":";;;;;;;cAoBa,WAAQ;;;;;;;;;;;UAA8B;;;;;;;;;;;4BAAA,eAAA,YAAA,cAAA,iCAAA;cACtC,mBAAgB;;;;;;;;;;;UAAsC;;;;;;;;;;;4BAAA,eAAA,YAAA,sBAAA;cACtD,cAAW,kCAAA,mBAAA,OAAA,8CAAA,gDAAA,4CAAA,kBAAA,YAAA,cAAA,iCAAA;cACX,sBAAmB,kCAAA,mBAAA,OAAA,sDAAA,gDAAA,4CAAA,kBAAA,YAAA,sBAAA;cACnB,qBAAkB;;;;;;;;;;UAAwC;;;;;;;;;;4BAAA,kBAAA,YAAA,cAAA,iCAAA;cAC1D,6BAA0B;;;;;;;;;;UAAgD;;;;;;;;;;4BAAA,kBAAA,YAAA,sBAAA;cAC1E,4BAAyB,wBAAA,OAAA,8CAAA,kEAAA,YAAA,YAAA,cAAA,iCAAA;cACzB,oCAAiC,wBAAA,OAAA,sDAAA,kEAAA,YAAA,YAAA,sBAAA;cACjC,aAAU;;;iBAA6B;;;mCAAA,cAAA,YAAA,cAAA,iCAAA;cACvC,qBAAkB;;;iBAAqC;;;mCAAA,cAAA,YAAA,sBAAA;cACvD,kBAAe,kCAAA,oBAAA,OAAA,8CAAA,iDAAA,6CAAA,cAAA,YAAA,cAAA,iCAAA;cACf,0BAAuB,kCAAA,oBAAA,OAAA,sDAAA,iDAAA,6CAAA,cAAA,YAAA,sBAAA;cACvB,yBAAsB;;;UAAyC;;;4BAAA,cAAA,YAAA,cAAA,iCAAA;cAC/D,iCAA8B;;;UAAiD;;;4BAAA,cAAA,YAAA,sBAAA;cAE/E,oBAAiB,UAAjB,4CAAiB,mDAAA,+CAAA,gBAAA,2CAAA,mDAAA,+CAAA;cACjB,yBAAsB,UAAtB,4CAAsB,wDAAA,oDAAA,gBAAA,2CAAA,wDAAA,oDAAA;cACtB,iBAAc,UAAd,4CAAc,gDAAA,8CAAA,gBAAA,2CAAA,gDAAA,8CAAA;cACd,2BAAwB,UAAxB,4CAAwB,0DAAA,wDAAA,gBAAA,2CAAA,0DAAA,wDAAA;cACxB,qBAAkB,UAAlB,4CAAkB,oDAAA,gDAAA,gBAAA,2CAAA,oDAAA,gDAAA"}

package/dist/hooks/reverse.d.ts

@@ -1,24 +1,24 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/reverse.d.ts
-declare const usePrimaryName: <Selected = {
+declare const usePrimaryName: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null>(input: UseEnsQueryParameters<import("@ensforge/core").GetPrimaryNameParameters, {
+} | null>(input: UseEnsAtomParameters<import("@ensforge/core").GetPrimaryNameParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetPrimaryNameError>;
-declare const usePrimaryNameSuspense: <Selected = {
+} | null, import("@ensforge/core").GetPrimaryNameError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetPrimaryNameError>;
+declare const usePrimaryNameSuspense: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetPrimaryNameParameters, {
+} | null>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetPrimaryNameParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null, Selected>) => EnsSuspenseQueryResult<Selected>;
+} | null, import("@ensforge/core").GetPrimaryNameError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useClearPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").ClearPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ClearPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetContractPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").SetContractPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetContractPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").SetPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

package/dist/hooks/reverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/hooks/reverse.ts"],"mappings":";;;;;;;cAaa,iBAAc;;;iBAAoC;;;UAAA,cAAA,eAAA,mCAAA;cAClD,yBAAsB;;;iBAA4C;;;UAAA,cAAA,uBAAA;cAElE,sBAAmB,UAAnB,4CAAmB,qDAAA,8CAAA,gBAAA,2CAAA,qDAAA,8CAAA;cACnB,4BAAyB,UAAzB,4CAAyB,2DAAA,8CAAA,gBAAA,2CAAA,2DAAA,8CAAA;cACzB,oBAAiB,UAAjB,4CAAiB,mDAAA,8CAAA,gBAAA,2CAAA,mDAAA,8CAAA;cACjB,8BAA2B,UAA3B,4CAA2B,6DAAA,8CAAA,gBAAA,2CAAA,6DAAA,8CAAA"}
+{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/hooks/reverse.ts"],"mappings":";;;;;;;cAaa,iBAAc;;;iBAAoC;;;mCAAA,qBAAA,YAAA,cAAA,iCAAA;cAClD,yBAAsB;;;iBAA4C;;;mCAAA,qBAAA,YAAA,sBAAA;cAElE,sBAAmB,UAAnB,4CAAmB,qDAAA,8CAAA,gBAAA,2CAAA,qDAAA,8CAAA;cACnB,4BAAyB,UAAzB,4CAAyB,2DAAA,8CAAA,gBAAA,2CAAA,2DAAA,8CAAA;cACzB,oBAAiB,UAAjB,4CAAiB,mDAAA,8CAAA,gBAAA,2CAAA,mDAAA,8CAAA;cACjB,8BAA2B,UAA3B,4CAA2B,6DAAA,8CAAA,gBAAA,2CAAA,6DAAA,8CAAA"}

package/dist/hooks/use-cache.d.ts

@@ -1,11 +1,11 @@
-import { EnsforgeInvalidation } from "../cache/invalidation.js";
+import { Invalidation } from "../cache/invalidation.js";
 import { Effect } from "effect";
 //#region src/hooks/use-cache.d.ts
-interface InvalidateEnsforge {
-  (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions): Promise<void>;
-  readonly effect: (invalidation?: EnsforgeInvalidation) => Effect.Effect<void>;
+interface Invalidate {
+  (invalidation?: Invalidation, options?: Effect.RunOptions): Promise<void>;
+  readonly effect: (invalidation?: Invalidation) => Effect.Effect<void>;
 }
-declare const useInvalidateEnsforge: () => InvalidateEnsforge;
+declare const useInvalidate: () => Invalidate;
 //#endregion
-export { InvalidateEnsforge, useInvalidateEnsforge };
+export { Invalidate, useInvalidate };
 //# sourceMappingURL=use-cache.d.ts.map

package/dist/hooks/use-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-cache.d.ts","names":[],"sources":["../../src/hooks/use-cache.ts"],"mappings":";;;UAUiB;GACd,eAAe,sBAAsB,UAAU,OAAO,aAAa;WAC3D,SAAS,eAAe,yBAAyB,OAAO;;cAGtD,6BAA4B"}
+{"version":3,"file":"use-cache.d.ts","names":[],"sources":["../../src/hooks/use-cache.ts"],"mappings":";;;UAUiB;GACd,eAAe,cAAc,UAAU,OAAO,aAAa;WACnD,SAAS,eAAe,iBAAiB,OAAO;;cAG9C,qBAAoB"}

package/dist/hooks/use-cache.js

@@ -1,20 +1,20 @@
 "use client";
 
-import { invalidateEnsforgeEffect } from "../cache/invalidation.js";
+import { invalidateEffect } from "../cache/invalidation.js";
 import { useEnsforgeContext } from "../provider/context.js";
 import { Effect } from "effect";
 import { RegistryContext } from "@effect/atom-react";
 import { useContext } from "react";
 
 //#region src/hooks/use-cache.ts
-const useInvalidateEnsforge = () => {
+const useInvalidate = () => {
 	const registry = useContext(RegistryContext);
 	const { sdk } = useEnsforgeContext();
-	const effect = (invalidation = { all: true }) => invalidateEnsforgeEffect(registry, sdk, invalidation);
+	const effect = (invalidation = { all: true }) => invalidateEffect(registry, sdk, invalidation);
 	const invalidate = (invalidation, options) => Effect.runPromise(effect(invalidation), options);
 	return Object.assign(invalidate, { effect });
 };
 
 //#endregion
-export { useInvalidateEnsforge };
+export { useInvalidate };
 //# sourceMappingURL=use-cache.js.map

package/dist/hooks/use-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-cache.js","names":[],"sources":["../../src/hooks/use-cache.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext } from \"@effect/atom-react\";\nimport { Effect } from \"effect\";\n\nimport { invalidateEnsforgeEffect, type EnsforgeInvalidation } from \"../cache/invalidation.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\n\nexport interface InvalidateEnsforge {\n  (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions): Promise<void>;\n  readonly effect: (invalidation?: EnsforgeInvalidation) => Effect.Effect<void>;\n}\n\nexport const useInvalidateEnsforge = (): InvalidateEnsforge => {\n  const registry = useContext(RegistryContext);\n  const { sdk } = useEnsforgeContext();\n  const effect = (invalidation: EnsforgeInvalidation = { all: true }) =>\n    invalidateEnsforgeEffect(registry, sdk, invalidation);\n  const invalidate = (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions) =>\n    Effect.runPromise(effect(invalidation), options);\n\n  return Object.assign(invalidate, { effect });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,8BAAkD;CAC7D,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,UAAU,eAAqC,EAAE,KAAK,KAAK,MAC/D,yBAAyB,UAAU,KAAK,YAAY;CACtD,MAAM,cAAc,cAAqC,YACvD,OAAO,WAAW,OAAO,YAAY,GAAG,OAAO;CAEjD,OAAO,OAAO,OAAO,YAAY,EAAE,OAAO,CAAC;AAC7C"}
+{"version":3,"file":"use-cache.js","names":[],"sources":["../../src/hooks/use-cache.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext } from \"@effect/atom-react\";\nimport { Effect } from \"effect\";\n\nimport { invalidateEffect, type Invalidation } from \"../cache/invalidation.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\n\nexport interface Invalidate {\n  (invalidation?: Invalidation, options?: Effect.RunOptions): Promise<void>;\n  readonly effect: (invalidation?: Invalidation) => Effect.Effect<void>;\n}\n\nexport const useInvalidate = (): Invalidate => {\n  const registry = useContext(RegistryContext);\n  const { sdk } = useEnsforgeContext();\n  const effect = (invalidation: Invalidation = { all: true }) =>\n    invalidateEffect(registry, sdk, invalidation);\n  const invalidate = (invalidation?: Invalidation, options?: Effect.RunOptions) =>\n    Effect.runPromise(effect(invalidation), options);\n\n  return Object.assign(invalidate, { effect });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,sBAAkC;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,UAAU,eAA6B,EAAE,KAAK,KAAK,MACvD,iBAAiB,UAAU,KAAK,YAAY;CAC9C,MAAM,cAAc,cAA6B,YAC/C,OAAO,WAAW,OAAO,YAAY,GAAG,OAAO;CAEjD,OAAO,OAAO,OAAO,YAAY,EAAE,OAAO,CAAC;AAC7C"}

package/dist/hooks/use-mutation.js

@@ -9,58 +9,44 @@ import { useContext, useRef, useState } from "react";
 
 //#region src/hooks/use-mutation.ts
 const makeMutationHook = (factory) => (options = {}) => {
-	const { sdk } = useEnsforgeContext();
+	const { defaults, sdk } = useEnsforgeContext();
 	const registry = useContext(RegistryContext);
 	const atomRef = useRef(void 0);
 	const [parameters, setParameters] = useState(void 0);
 	if (atomRef.current === void 0) atomRef.current = factory(sdk);
 	const atom = atomRef.current;
 	const result = useAtomValue(atom);
+	const retry = options.retry ?? defaults.mutations?.retry ?? false;
 	const mutateEffect = (nextParameters) => {
 		const effect = Effect.sync(() => {
 			setParameters(nextParameters);
 			registry.set(atom, nextParameters);
 		}).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
-		return options.retry === void 0 || options.retry === false ? effect : effect.pipe(Effect.retry({ times: options.retry }));
+		return retry === false ? effect : effect.pipe(Effect.retry(retry));
 	};
-	const runCallbacks = (exit, nextParameters, local) => {
-		if (Exit.isSuccess(exit)) {
-			options.onSuccess?.(exit.value, nextParameters);
-			local?.onSuccess?.(exit.value, nextParameters);
-			options.onSettled?.(exit.value, null, nextParameters);
-			local?.onSettled?.(exit.value, null, nextParameters);
-			return;
-		}
-		const error = errorFromCause(exit.cause);
-		options.onError?.(error, nextParameters);
-		local?.onError?.(error, nextParameters);
-		options.onSettled?.(void 0, error, nextParameters);
-		local?.onSettled?.(void 0, error, nextParameters);
-	};
-	const mutate = (nextParameters, callbacks) => {
-		Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) => runCallbacks(exit, nextParameters, callbacks));
+	const notifyExit = (exit, nextParameters, local) => {
+		options.onExit?.(exit, nextParameters);
+		local?.onExit?.(exit, nextParameters);
 	};
 	const mutateAsync = async (nextParameters) => {
 		const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));
-		runCallbacks(exit, nextParameters, void 0);
+		notifyExit(exit, nextParameters, void 0);
 		if (Exit.isSuccess(exit)) return exit.value;
 		throw Cause.squash(exit.cause);
 	};
+	const mutate = (nextParameters, local) => {
+		Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) => notifyExit(exit, nextParameters, local));
+	};
 	const cause = Option.getOrNull(AsyncResult.cause(result));
-	const data = Option.getOrUndefined(AsyncResult.value(result));
-	const isIdle = AsyncResult.isInitial(result) && !result.waiting;
-	const isPending = result.waiting;
-	const isError = AsyncResult.isFailure(result);
-	const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;
 	return {
 		cause,
-		data,
+		data: Option.getOrUndefined(AsyncResult.value(result)),
 		error: cause === null ? null : errorFromCause(cause),
 		interrupt: () => registry.set(atom, Atom.Interrupt),
-		isError,
-		isIdle,
-		isPending,
-		isSuccess,
+		isFailure: AsyncResult.isFailure(result),
+		isInitial: AsyncResult.isInitial(result) && !result.waiting,
+		isSuccess: AsyncResult.isSuccess(result) && !result.waiting,
+		isWaiting: result.waiting,
 		mutate,
 		mutateAsync,
 		mutateEffect,
@@ -69,8 +55,7 @@ const makeMutationHook = (factory) => (options = {}) => {
 			setParameters(void 0);
 			registry.set(atom, Atom.Reset);
 		},
-		result,
-		status: isPending ? "pending" : isError ? "error" : isSuccess ? "success" : "idle"
+		result
 	};
 };
 

package/dist/hooks/use-mutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-mutation.js","names":[],"sources":["../../src/hooks/use-mutation.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useRef, useState } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Cause, Effect, Exit, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsMutationAtomFactory } from \"../atoms/mutation.js\";\nimport type { EnsMutationCallbacks, EnsMutationOptions } from \"../mutation/options.js\";\nimport type { EnsMutationResult } from \"../mutation/result.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport { errorFromCause } from \"../query/result.js\";\n\nexport const makeMutationHook =\n  <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) =>\n  (\n    options: EnsMutationOptions<Parameters, Success, Failure> = {},\n  ): EnsMutationResult<Parameters, Success, Failure> => {\n    const { sdk } = useEnsforgeContext();\n    const registry = useContext(RegistryContext);\n    const atomRef = useRef<ReturnType<typeof factory> | undefined>(undefined);\n    const [parameters, setParameters] = useState<Parameters | undefined>(undefined);\n    if (atomRef.current === undefined) atomRef.current = factory(sdk);\n    const atom = atomRef.current;\n    const result = useAtomValue(atom);\n\n    const mutateEffect = (nextParameters: Parameters): Effect.Effect<Success, Failure> => {\n      const effect = Effect.sync(() => {\n        setParameters(nextParameters);\n        registry.set(atom, nextParameters);\n      }).pipe(\n        Effect.andThen(\n          AtomRegistry.getResult(registry, atom, {\n            suspendOnWaiting: true,\n          }),\n        ),\n      );\n      return options.retry === undefined || options.retry === false\n        ? effect\n        : effect.pipe(Effect.retry({ times: options.retry }));\n    };\n\n    const runCallbacks = (\n      exit: Exit.Exit<Success, Failure>,\n      nextParameters: Parameters,\n      local: EnsMutationCallbacks<Parameters, Success, Failure> | undefined,\n    ) => {\n      if (Exit.isSuccess(exit)) {\n        options.onSuccess?.(exit.value, nextParameters);\n        local?.onSuccess?.(exit.value, nextParameters);\n        options.onSettled?.(exit.value, null, nextParameters);\n        local?.onSettled?.(exit.value, null, nextParameters);\n        return;\n      }\n\n      const error = errorFromCause(exit.cause);\n      options.onError?.(error, nextParameters);\n      local?.onError?.(error, nextParameters);\n      options.onSettled?.(undefined, error, nextParameters);\n      local?.onSettled?.(undefined, error, nextParameters);\n    };\n\n    const mutate = (\n      nextParameters: Parameters,\n      callbacks?: EnsMutationCallbacks<Parameters, Success, Failure>,\n    ) => {\n      void Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) =>\n        runCallbacks(exit, nextParameters, callbacks),\n      );\n    };\n\n    const mutateAsync = async (nextParameters: Parameters): Promise<Success> => {\n      const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));\n      runCallbacks(exit, nextParameters, undefined);\n      if (Exit.isSuccess(exit)) return exit.value;\n      throw Cause.squash(exit.cause);\n    };\n\n    const cause = Option.getOrNull(AsyncResult.cause(result));\n    const data = Option.getOrUndefined(AsyncResult.value(result));\n    const isIdle = AsyncResult.isInitial(result) && !result.waiting;\n    const isPending = result.waiting;\n    const isError = AsyncResult.isFailure(result);\n    const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;\n\n    return {\n      cause,\n      data,\n      error: cause === null ? null : errorFromCause(cause),\n      interrupt: () => registry.set(atom, Atom.Interrupt),\n      isError,\n      isIdle,\n      isPending,\n      isSuccess,\n      mutate,\n      mutateAsync,\n      mutateEffect,\n      parameters,\n      reset: () => {\n        setParameters(undefined);\n        registry.set(atom, Atom.Reset);\n      },\n      result,\n      status: isPending ? \"pending\" : isError ? \"error\" : isSuccess ? \"success\" : \"idle\",\n    };\n  };\n"],"mappings":";;;;;;;;;;AAcA,MAAa,oBACoB,aAE7B,UAA4D,CAAC,MACT;CACpD,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,UAAU,OAA+C,MAAS;CACxE,MAAM,CAAC,YAAY,iBAAiB,SAAiC,MAAS;CAC9E,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,QAAQ,GAAG;CAChE,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAS,aAAa,IAAI;CAEhC,MAAM,gBAAgB,mBAAgE;EACpF,MAAM,SAAS,OAAO,WAAW;GAC/B,cAAc,cAAc;GAC5B,SAAS,IAAI,MAAM,cAAc;EACnC,CAAC,CAAC,CAAC,KACD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,QAAQ,UAAU,UAAa,QAAQ,UAAU,QACpD,SACA,OAAO,KAAK,OAAO,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,CAAC;CACxD;CAEA,MAAM,gBACJ,MACA,gBACA,UACG;EACH,IAAI,KAAK,UAAU,IAAI,GAAG;GACxB,QAAQ,YAAY,KAAK,OAAO,cAAc;GAC9C,OAAO,YAAY,KAAK,OAAO,cAAc;GAC7C,QAAQ,YAAY,KAAK,OAAO,MAAM,cAAc;GACpD,OAAO,YAAY,KAAK,OAAO,MAAM,cAAc;GACnD;EACF;EAEA,MAAM,QAAQ,eAAe,KAAK,KAAK;EACvC,QAAQ,UAAU,OAAO,cAAc;EACvC,OAAO,UAAU,OAAO,cAAc;EACtC,QAAQ,YAAY,QAAW,OAAO,cAAc;EACpD,OAAO,YAAY,QAAW,OAAO,cAAc;CACrD;CAEA,MAAM,UACJ,gBACA,cACG;EACH,AAAK,OAAO,eAAe,aAAa,cAAc,CAAC,CAAC,CAAC,MAAM,SAC7D,aAAa,MAAM,gBAAgB,SAAS,CAC9C;CACF;CAEA,MAAM,cAAc,OAAO,mBAAiD;EAC1E,MAAM,OAAO,MAAM,OAAO,eAAe,aAAa,cAAc,CAAC;EACrE,aAAa,MAAM,gBAAgB,MAAS;EAC5C,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;EACtC,MAAM,MAAM,OAAO,KAAK,KAAK;CAC/B;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CACxD,MAAM,OAAO,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;CAC5D,MAAM,SAAS,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CACxD,MAAM,YAAY,OAAO;CACzB,MAAM,UAAU,YAAY,UAAU,MAAM;CAC5C,MAAM,YAAY,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CAE3D,OAAO;EACL;EACA;EACA,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,iBAAiB,SAAS,IAAI,MAAM,KAAK,SAAS;EAClD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa;GACX,cAAc,MAAS;GACvB,SAAS,IAAI,MAAM,KAAK,KAAK;EAC/B;EACA;EACA,QAAQ,YAAY,YAAY,UAAU,UAAU,YAAY,YAAY;CAC9E;AACF"}
+{"version":3,"file":"use-mutation.js","names":[],"sources":["../../src/hooks/use-mutation.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useRef, useState } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Cause, Effect, Exit, Option, type Schedule } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsMutationAtomFactory } from \"../atoms/mutation.js\";\nimport type { EnsMutationExecutionOptions, EnsMutationOptions } from \"../mutation/options.js\";\nimport type { EnsMutationResult } from \"../mutation/result.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport { errorFromCause } from \"../query/result.js\";\n\nexport const makeMutationHook =\n  <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) =>\n  (\n    options: EnsMutationOptions<Parameters, Success, Failure> = {},\n  ): EnsMutationResult<Parameters, Success, Failure> => {\n    const { defaults, sdk } = useEnsforgeContext();\n    const registry = useContext(RegistryContext);\n    const atomRef = useRef<ReturnType<typeof factory> | undefined>(undefined);\n    const [parameters, setParameters] = useState<Parameters | undefined>(undefined);\n    if (atomRef.current === undefined) atomRef.current = factory(sdk);\n    const atom = atomRef.current;\n    const result = useAtomValue(atom);\n    const retry =\n      options.retry ??\n      (defaults.mutations?.retry as false | Schedule.Schedule<unknown, Failure> | undefined) ??\n      false;\n\n    const mutateEffect = (nextParameters: Parameters): Effect.Effect<Success, Failure> => {\n      const effect = Effect.sync(() => {\n        setParameters(nextParameters);\n        registry.set(atom, nextParameters);\n      }).pipe(\n        Effect.andThen(\n          AtomRegistry.getResult(registry, atom, {\n            suspendOnWaiting: true,\n          }),\n        ),\n      );\n      return retry === false ? effect : effect.pipe(Effect.retry(retry));\n    };\n\n    const notifyExit = (\n      exit: Exit.Exit<Success, Failure>,\n      nextParameters: Parameters,\n      local: EnsMutationExecutionOptions<Parameters, Success, Failure> | undefined,\n    ) => {\n      options.onExit?.(exit, nextParameters);\n      local?.onExit?.(exit, nextParameters);\n    };\n\n    const mutateAsync = async (nextParameters: Parameters): Promise<Success> => {\n      const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));\n      notifyExit(exit, nextParameters, undefined);\n      if (Exit.isSuccess(exit)) return exit.value;\n      throw Cause.squash(exit.cause);\n    };\n\n    const mutate = (\n      nextParameters: Parameters,\n      local?: EnsMutationExecutionOptions<Parameters, Success, Failure>,\n    ) => {\n      void Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) =>\n        notifyExit(exit, nextParameters, local),\n      );\n    };\n\n    const cause = Option.getOrNull(AsyncResult.cause(result));\n\n    return {\n      cause,\n      data: Option.getOrUndefined(AsyncResult.value(result)),\n      error: cause === null ? null : errorFromCause(cause),\n      interrupt: () => registry.set(atom, Atom.Interrupt),\n      isFailure: AsyncResult.isFailure(result),\n      isInitial: AsyncResult.isInitial(result) && !result.waiting,\n      isSuccess: AsyncResult.isSuccess(result) && !result.waiting,\n      isWaiting: result.waiting,\n      mutate,\n      mutateAsync,\n      mutateEffect,\n      parameters,\n      reset: () => {\n        setParameters(undefined);\n        registry.set(atom, Atom.Reset);\n      },\n      result,\n    };\n  };\n"],"mappings":";;;;;;;;;;AAcA,MAAa,oBACoB,aAE7B,UAA4D,CAAC,MACT;CACpD,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,UAAU,OAA+C,MAAS;CACxE,MAAM,CAAC,YAAY,iBAAiB,SAAiC,MAAS;CAC9E,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,QAAQ,GAAG;CAChE,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAS,aAAa,IAAI;CAChC,MAAM,QACJ,QAAQ,SACP,SAAS,WAAW,SACrB;CAEF,MAAM,gBAAgB,mBAAgE;EACpF,MAAM,SAAS,OAAO,WAAW;GAC/B,cAAc,cAAc;GAC5B,SAAS,IAAI,MAAM,cAAc;EACnC,CAAC,CAAC,CAAC,KACD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,UAAU,QAAQ,SAAS,OAAO,KAAK,OAAO,MAAM,KAAK,CAAC;CACnE;CAEA,MAAM,cACJ,MACA,gBACA,UACG;EACH,QAAQ,SAAS,MAAM,cAAc;EACrC,OAAO,SAAS,MAAM,cAAc;CACtC;CAEA,MAAM,cAAc,OAAO,mBAAiD;EAC1E,MAAM,OAAO,MAAM,OAAO,eAAe,aAAa,cAAc,CAAC;EACrE,WAAW,MAAM,gBAAgB,MAAS;EAC1C,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;EACtC,MAAM,MAAM,OAAO,KAAK,KAAK;CAC/B;CAEA,MAAM,UACJ,gBACA,UACG;EACH,AAAK,OAAO,eAAe,aAAa,cAAc,CAAC,CAAC,CAAC,MAAM,SAC7D,WAAW,MAAM,gBAAgB,KAAK,CACxC;CACF;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CAExD,OAAO;EACL;EACA,MAAM,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;EACrD,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,iBAAiB,SAAS,IAAI,MAAM,KAAK,SAAS;EAClD,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;EACpD,WAAW,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;EACpD,WAAW,OAAO;EAClB;EACA;EACA;EACA;EACA,aAAa;GACX,cAAc,MAAS;GACvB,SAAS,IAAI,MAAM,KAAK,KAAK;EAC/B;EACA;CACF;AACF"}

package/dist/hooks/use-query.d.ts

@@ -1,10 +1,10 @@
-import { EnsQueryAtomFactory } from "../atoms/query.js";
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsAtomFactory } from "../atoms/query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
 //#region src/hooks/use-query.d.ts
-declare const makeQueryHook: <Parameters extends object, Success, Failure>(factory: EnsQueryAtomFactory<Parameters, Success, Failure>) => <Selected = Success>(input: UseEnsQueryParameters<Parameters, Success, Selected>) => EnsQueryResult<Selected, Failure>;
-declare const prefetchQueryAtom: <Success, Failure>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>, signal?: AbortSignal) => Promise<Success>;
+declare const makeQueryHook: <Parameters extends object, Success, Failure>(factory: EnsAtomFactory<Parameters, Success, Failure>) => <Mapped = Success>(input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>) => EnsAtomResult<Mapped, Failure>;
+declare const prefetchAtom: <Success, Failure>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>, signal?: AbortSignal) => Promise<Success>;
 //#endregion
-export { makeQueryHook, prefetchQueryAtom };
+export { makeQueryHook, prefetchAtom };
 //# sourceMappingURL=use-query.d.ts.map

package/dist/hooks/use-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.d.ts","names":[],"sources":["../../src/hooks/use-query.ts"],"mappings":";;;;;cAiGa,gBACV,2BAA2B,SAAS,SACnC,SAAS,oBAAoB,YAAY,SAAS,cAEnD,WAAW,SACV,OAAO,sBAAsB,YAAY,SAAS,cACjD,eAAe,UAAU;cAGjB,oBAAqB,SAAS,SACzC,UAAU,aAAa,cACvB,MAAM,KAAK,KAAK,YAAY,YAAY,SAAS,WACjD,SAAS,gBACR,QAAQ"}
+{"version":3,"file":"use-query.d.ts","names":[],"sources":["../../src/hooks/use-query.ts"],"mappings":";;;;;cAiFa,gBACV,2BAA2B,SAAS,SACnC,SAAS,eAAe,YAAY,SAAS,cAE9C,SAAS,SACR,OAAO,qBAAqB,YAAY,SAAS,SAAS,YACzD,cAAc,QAAQ;cAGd,eAAgB,SAAS,SACpC,UAAU,aAAa,cACvB,MAAM,KAAK,KAAK,YAAY,YAAY,SAAS,WACjD,SAAS,gBACR,QAAQ"}

package/dist/hooks/use-query.js

@@ -1,81 +1,53 @@
 "use client";
 
+import { resolveEnsAtomOptions } from "../query/options.js";
 import { useEnsforgeContext } from "../provider/context.js";
 import { errorFromCause, resultUpdatedAt } from "../query/result.js";
-import { resolveEnsQueryOptions } from "../query/options.js";
 import { Effect, Option } from "effect";
 import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
 import { RegistryContext, useAtomValue } from "@effect/atom-react";
-import { useContext, useEffect, useRef } from "react";
+import { useContext } from "react";
 
 //#region src/hooks/use-query.ts
 const disabledAtom = Atom.make(AsyncResult.initial());
-const splitQueryParameters = (input) => {
-	const { query, ...parameters } = input;
-	return [parameters, query];
+const splitAtomParameters = (input) => {
+	const { atom, enabled = true, map, ...parameters } = input;
+	return {
+		atom,
+		enabled,
+		map,
+		parameters
+	};
 };
 const useQueryAtom = (factory, input) => {
 	const { defaults, sdk } = useEnsforgeContext();
 	const registry = useContext(RegistryContext);
-	const [parameters, query] = splitQueryParameters(input);
-	const options = resolveEnsQueryOptions(defaults.queries, query);
-	const enabled = query?.enabled ?? true;
-	const atom = factory(sdk, parameters, options);
+	const { atom: atomOptions, enabled, map, parameters } = splitAtomParameters(input);
+	const atom = factory(sdk, parameters, resolveEnsAtomOptions(defaults.atoms, atomOptions));
 	const rawResult = useAtomValue(enabled ? atom : disabledAtom);
-	const result = query?.select === void 0 ? rawResult : AsyncResult.map(rawResult, query.select);
-	const staleCheckedAtom = useRef(void 0);
-	useEffect(() => {
-		if (staleCheckedAtom.current === atom) return;
-		staleCheckedAtom.current = atom;
-		if (!enabled || !AsyncResult.isSuccess(rawResult)) return;
-		if (Date.now() - rawResult.timestamp >= options.staleTime) registry.refresh(atom);
-	}, [
-		atom,
-		enabled,
-		options.staleTime,
-		rawResult,
-		registry
-	]);
-	useEffect(() => {
-		if (!enabled || options.refetchInterval === false) return;
-		const interval = globalThis.setInterval(() => registry.refresh(atom), options.refetchInterval);
-		return () => globalThis.clearInterval(interval);
-	}, [
-		atom,
-		enabled,
-		options.refetchInterval,
-		registry
-	]);
-	const refetchEffect = () => {
+	const result = map === void 0 ? rawResult : AsyncResult.map(rawResult, map);
+	const refreshEffect = () => {
 		const effect = Effect.sync(() => registry.refresh(atom)).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
-		return query?.select === void 0 ? effect : effect.pipe(Effect.map(query.select));
+		return map === void 0 ? effect : effect.pipe(Effect.map(map));
 	};
 	const cause = Option.getOrNull(AsyncResult.cause(result));
-	const data = Option.getOrUndefined(AsyncResult.value(result));
-	const isPending = AsyncResult.isInitial(result);
-	const isError = AsyncResult.isFailure(result);
-	const isSuccess = AsyncResult.isSuccess(result);
 	return {
 		cause,
-		data,
+		data: Option.getOrUndefined(AsyncResult.value(result)),
 		error: cause === null ? null : errorFromCause(cause),
-		fetchStatus: result.waiting ? "fetching" : "idle",
-		isError,
-		isFetching: result.waiting,
-		isLoading: isPending && result.waiting,
-		isPending,
-		isRefetching: !isPending && result.waiting,
-		isSuccess,
-		refetch: () => Effect.runPromise(refetchEffect()),
-		refetchEffect,
+		isFailure: AsyncResult.isFailure(result),
+		isInitial: AsyncResult.isInitial(result),
+		isSuccess: AsyncResult.isSuccess(result),
+		isWaiting: result.waiting,
+		refresh: () => Effect.runPromise(refreshEffect()),
+		refreshEffect,
 		result,
-		status: isPending ? "pending" : isError ? "error" : "success",
 		updatedAt: resultUpdatedAt(result)
 	};
 };
 const makeQueryHook = (factory) => (input) => useQueryAtom(factory, input);
-const prefetchQueryAtom = (registry, atom, signal) => Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), { signal });
+const prefetchAtom = (registry, atom, signal) => Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), { signal });
 
 //#endregion
-export { makeQueryHook, prefetchQueryAtom, useQueryAtom };
+export { makeQueryHook, prefetchAtom, useQueryAtom };
 //# sourceMappingURL=use-query.js.map

package/dist/hooks/use-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.js","names":[],"sources":["../../src/hooks/use-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useEffect, useRef } from \"react\";\n\nimport { useAtomValue, RegistryContext } from \"@effect/atom-react\";\nimport { Effect, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsQueryAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsQueryOptions,\n  type EnsQueryOptions,\n  type UseEnsQueryParameters,\n} from \"../query/options.js\";\nimport { errorFromCause, resultUpdatedAt, type EnsQueryResult } from \"../query/result.js\";\n\nconst disabledAtom = Atom.make(AsyncResult.initial<unknown, unknown>());\n\nconst splitQueryParameters = <Parameters extends object, Success, Selected>(\n  input: UseEnsQueryParameters<Parameters, Success, Selected>,\n): readonly [Parameters, EnsQueryOptions<Success, Selected> | undefined] => {\n  const { query, ...parameters } = input;\n  return [parameters as Parameters, query];\n};\n\nexport const useQueryAtom = <Parameters extends object, Success, Failure, Selected = Success>(\n  factory: EnsQueryAtomFactory<Parameters, Success, Failure>,\n  input: UseEnsQueryParameters<Parameters, Success, Selected>,\n): EnsQueryResult<Selected, Failure> => {\n  const { defaults, sdk } = useEnsforgeContext();\n  const registry = useContext(RegistryContext);\n  const [parameters, query] = splitQueryParameters(input);\n  const options = resolveEnsQueryOptions(defaults.queries, query);\n  const enabled = query?.enabled ?? true;\n  const atom = factory(sdk, parameters, options);\n  const activeAtom = (enabled ? atom : disabledAtom) as Atom.Atom<\n    AsyncResult.AsyncResult<Success, Failure>\n  >;\n  const rawResult = useAtomValue(activeAtom);\n  const result: AsyncResult.AsyncResult<Selected, Failure> =\n    query?.select === undefined\n      ? (rawResult as unknown as AsyncResult.AsyncResult<Selected, Failure>)\n      : AsyncResult.map(rawResult, query.select);\n  const staleCheckedAtom = useRef<Atom.Atom<unknown> | undefined>(undefined);\n\n  useEffect(() => {\n    if (staleCheckedAtom.current === atom) return;\n    staleCheckedAtom.current = atom;\n    if (!enabled || !AsyncResult.isSuccess(rawResult)) return;\n    if (Date.now() - rawResult.timestamp >= options.staleTime) registry.refresh(atom);\n  }, [atom, enabled, options.staleTime, rawResult, registry]);\n\n  useEffect(() => {\n    if (!enabled || options.refetchInterval === false) return;\n    const interval = globalThis.setInterval(() => registry.refresh(atom), options.refetchInterval);\n    return () => globalThis.clearInterval(interval);\n  }, [atom, enabled, options.refetchInterval, registry]);\n\n  const refetchEffect = (): Effect.Effect<Selected, Failure> => {\n    const effect = Effect.sync(() => registry.refresh(atom)).pipe(\n      Effect.andThen(\n        AtomRegistry.getResult(registry, atom, {\n          suspendOnWaiting: true,\n        }),\n      ),\n    );\n    return query?.select === undefined\n      ? (effect as unknown as Effect.Effect<Selected, Failure>)\n      : effect.pipe(Effect.map(query.select));\n  };\n\n  const cause = Option.getOrNull(AsyncResult.cause(result));\n  const data = Option.getOrUndefined(AsyncResult.value(result));\n  const isPending = AsyncResult.isInitial(result);\n  const isError = AsyncResult.isFailure(result);\n  const isSuccess = AsyncResult.isSuccess(result);\n\n  return {\n    cause,\n    data,\n    error: cause === null ? null : errorFromCause(cause),\n    fetchStatus: result.waiting ? \"fetching\" : \"idle\",\n    isError,\n    isFetching: result.waiting,\n    isLoading: isPending && result.waiting,\n    isPending,\n    isRefetching: !isPending && result.waiting,\n    isSuccess,\n    refetch: () => Effect.runPromise(refetchEffect()),\n    refetchEffect,\n    result,\n    status: isPending ? \"pending\" : isError ? \"error\" : \"success\",\n    updatedAt: resultUpdatedAt(result),\n  };\n};\n\nexport const makeQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsQueryAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Selected = Success>(\n    input: UseEnsQueryParameters<Parameters, Success, Selected>,\n  ): EnsQueryResult<Selected, Failure> =>\n    useQueryAtom(factory, input);\n\nexport const prefetchQueryAtom = <Success, Failure>(\n  registry: AtomRegistry.AtomRegistry,\n  atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>,\n  signal?: AbortSignal,\n): Promise<Success> =>\n  Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), {\n    signal,\n  });\n"],"mappings":";;;;;;;;;;;AAiBA,MAAM,eAAe,KAAK,KAAK,YAAY,QAA0B,CAAC;AAEtE,MAAM,wBACJ,UAC0E;CAC1E,MAAM,EAAE,OAAO,GAAG,eAAe;CACjC,OAAO,CAAC,YAA0B,KAAK;AACzC;AAEA,MAAa,gBACX,SACA,UACsC;CACtC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,CAAC,YAAY,SAAS,qBAAqB,KAAK;CACtD,MAAM,UAAU,uBAAuB,SAAS,SAAS,KAAK;CAC9D,MAAM,UAAU,OAAO,WAAW;CAClC,MAAM,OAAO,QAAQ,KAAK,YAAY,OAAO;CAI7C,MAAM,YAAY,aAHE,UAAU,OAAO,YAGI;CACzC,MAAM,SACJ,OAAO,WAAW,SACb,YACD,YAAY,IAAI,WAAW,MAAM,MAAM;CAC7C,MAAM,mBAAmB,OAAuC,MAAS;CAEzE,gBAAgB;EACd,IAAI,iBAAiB,YAAY,MAAM;EACvC,iBAAiB,UAAU;EAC3B,IAAI,CAAC,WAAW,CAAC,YAAY,UAAU,SAAS,GAAG;EACnD,IAAI,KAAK,IAAI,IAAI,UAAU,aAAa,QAAQ,WAAW,SAAS,QAAQ,IAAI;CAClF,GAAG;EAAC;EAAM;EAAS,QAAQ;EAAW;EAAW;CAAQ,CAAC;CAE1D,gBAAgB;EACd,IAAI,CAAC,WAAW,QAAQ,oBAAoB,OAAO;EACnD,MAAM,WAAW,WAAW,kBAAkB,SAAS,QAAQ,IAAI,GAAG,QAAQ,eAAe;EAC7F,aAAa,WAAW,cAAc,QAAQ;CAChD,GAAG;EAAC;EAAM;EAAS,QAAQ;EAAiB;CAAQ,CAAC;CAErD,MAAM,sBAAwD;EAC5D,MAAM,SAAS,OAAO,WAAW,SAAS,QAAQ,IAAI,CAAC,CAAC,CAAC,KACvD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,OAAO,WAAW,SACpB,SACD,OAAO,KAAK,OAAO,IAAI,MAAM,MAAM,CAAC;CAC1C;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CACxD,MAAM,OAAO,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;CAC5D,MAAM,YAAY,YAAY,UAAU,MAAM;CAC9C,MAAM,UAAU,YAAY,UAAU,MAAM;CAC5C,MAAM,YAAY,YAAY,UAAU,MAAM;CAE9C,OAAO;EACL;EACA;EACA,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,aAAa,OAAO,UAAU,aAAa;EAC3C;EACA,YAAY,OAAO;EACnB,WAAW,aAAa,OAAO;EAC/B;EACA,cAAc,CAAC,aAAa,OAAO;EACnC;EACA,eAAe,OAAO,WAAW,cAAc,CAAC;EAChD;EACA;EACA,QAAQ,YAAY,YAAY,UAAU,UAAU;EACpD,WAAW,gBAAgB,MAAM;CACnC;AACF;AAEA,MAAa,iBAET,aAGA,UAEA,aAAa,SAAS,KAAK;AAE/B,MAAa,qBACX,UACA,MACA,WAEA,OAAO,WAAW,aAAa,UAAU,UAAU,MAAM,EAAE,kBAAkB,KAAK,CAAC,GAAG,EACpF,OACF,CAAC"}
+{"version":3,"file":"use-query.js","names":[],"sources":["../../src/hooks/use-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Effect, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsAtomOptions,\n  type EnsAtomOptions,\n  type UseEnsAtomParameters,\n} from \"../query/options.js\";\nimport { errorFromCause, resultUpdatedAt, type EnsAtomResult } from \"../query/result.js\";\n\nconst disabledAtom = Atom.make(AsyncResult.initial<unknown, unknown>());\n\ninterface SplitAtomParameters<Parameters, Success, Failure, Mapped> {\n  readonly atom: EnsAtomOptions<Failure> | undefined;\n  readonly enabled: boolean;\n  readonly map: ((value: Success) => Mapped) | undefined;\n  readonly parameters: Parameters;\n}\n\nconst splitAtomParameters = <Parameters extends object, Success, Failure, Mapped>(\n  input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n): SplitAtomParameters<Parameters, Success, Failure, Mapped> => {\n  const { atom, enabled = true, map, ...parameters } = input;\n  return { atom, enabled, map, parameters: parameters as Parameters };\n};\n\nexport const useQueryAtom = <Parameters extends object, Success, Failure, Mapped = Success>(\n  factory: EnsAtomFactory<Parameters, Success, Failure>,\n  input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n): EnsAtomResult<Mapped, Failure> => {\n  const { defaults, sdk } = useEnsforgeContext();\n  const registry = useContext(RegistryContext);\n  const { atom: atomOptions, enabled, map, parameters } = splitAtomParameters(input);\n  const options = resolveEnsAtomOptions(defaults.atoms, atomOptions);\n  const atom = factory(sdk, parameters, options);\n  const activeAtom = (enabled ? atom : disabledAtom) as Atom.Atom<\n    AsyncResult.AsyncResult<Success, Failure>\n  >;\n  const rawResult = useAtomValue(activeAtom);\n  const result: AsyncResult.AsyncResult<Mapped, Failure> =\n    map === undefined\n      ? (rawResult as unknown as AsyncResult.AsyncResult<Mapped, Failure>)\n      : AsyncResult.map(rawResult, map);\n\n  const refreshEffect = (): Effect.Effect<Mapped, Failure> => {\n    const effect = Effect.sync(() => registry.refresh(atom)).pipe(\n      Effect.andThen(\n        AtomRegistry.getResult(registry, atom, {\n          suspendOnWaiting: true,\n        }),\n      ),\n    );\n    return map === undefined\n      ? (effect as unknown as Effect.Effect<Mapped, Failure>)\n      : effect.pipe(Effect.map(map));\n  };\n\n  const cause = Option.getOrNull(AsyncResult.cause(result));\n\n  return {\n    cause,\n    data: Option.getOrUndefined(AsyncResult.value(result)),\n    error: cause === null ? null : errorFromCause(cause),\n    isFailure: AsyncResult.isFailure(result),\n    isInitial: AsyncResult.isInitial(result),\n    isSuccess: AsyncResult.isSuccess(result),\n    isWaiting: result.waiting,\n    refresh: () => Effect.runPromise(refreshEffect()),\n    refreshEffect,\n    result,\n    updatedAt: resultUpdatedAt(result),\n  };\n};\n\nexport const makeQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Mapped = Success>(\n    input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n  ): EnsAtomResult<Mapped, Failure> =>\n    useQueryAtom(factory, input);\n\nexport const prefetchAtom = <Success, Failure>(\n  registry: AtomRegistry.AtomRegistry,\n  atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>,\n  signal?: AbortSignal,\n): Promise<Success> =>\n  Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), {\n    signal,\n  });\n"],"mappings":";;;;;;;;;;;AAiBA,MAAM,eAAe,KAAK,KAAK,YAAY,QAA0B,CAAC;AAStE,MAAM,uBACJ,UAC8D;CAC9D,MAAM,EAAE,MAAM,UAAU,MAAM,KAAK,GAAG,eAAe;CACrD,OAAO;EAAE;EAAM;EAAS;EAAiB;CAAyB;AACpE;AAEA,MAAa,gBACX,SACA,UACmC;CACnC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,MAAM,aAAa,SAAS,KAAK,eAAe,oBAAoB,KAAK;CAEjF,MAAM,OAAO,QAAQ,KAAK,YADV,sBAAsB,SAAS,OAAO,WACV,CAAC;CAI7C,MAAM,YAAY,aAHE,UAAU,OAAO,YAGI;CACzC,MAAM,SACJ,QAAQ,SACH,YACD,YAAY,IAAI,WAAW,GAAG;CAEpC,MAAM,sBAAsD;EAC1D,MAAM,SAAS,OAAO,WAAW,SAAS,QAAQ,IAAI,CAAC,CAAC,CAAC,KACvD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,QAAQ,SACV,SACD,OAAO,KAAK,OAAO,IAAI,GAAG,CAAC;CACjC;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CAExD,OAAO;EACL;EACA,MAAM,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;EACrD,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,OAAO;EAClB,eAAe,OAAO,WAAW,cAAc,CAAC;EAChD;EACA;EACA,WAAW,gBAAgB,MAAM;CACnC;AACF;AAEA,MAAa,iBAET,aAGA,UAEA,aAAa,SAAS,KAAK;AAE/B,MAAa,gBACX,UACA,MACA,WAEA,OAAO,WAAW,aAAa,UAAU,UAAU,MAAM,EAAE,kBAAkB,KAAK,CAAC,GAAG,EACpF,OACF,CAAC"}

package/dist/hooks/use-suspense-query.d.ts

@@ -1,15 +1,16 @@
-import { EnsQueryAtomFactory } from "../atoms/query.js";
-import { EnsQueryOptions } from "../query/options.js";
+import { EnsAtomOptions } from "../query/options.js";
+import { EnsAtomFactory } from "../atoms/query.js";
 //#region src/hooks/use-suspense-query.d.ts
-type UseEnsSuspenseQueryParameters<Parameters, Success, Selected = Success> = Parameters & {
-  readonly query?: Omit<EnsQueryOptions<Success, Selected>, "enabled">;
+type UseEnsSuspenseAtomParameters<Parameters, Success, Failure, Mapped = Success> = Parameters & {
+  readonly atom?: EnsAtomOptions<Failure>;
+  readonly map?: (value: Success) => Mapped;
 };
-interface EnsSuspenseQueryResult<Success> {
+interface EnsSuspenseAtomResult<Success> {
   readonly data: Success;
-  readonly isFetching: boolean;
+  readonly isWaiting: boolean;
   readonly updatedAt: number;
 }
-declare const makeSuspenseQueryHook: <Parameters extends object, Success, Failure>(factory: EnsQueryAtomFactory<Parameters, Success, Failure>) => <Selected = Success>(input: UseEnsSuspenseQueryParameters<Parameters, Success, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const makeSuspenseQueryHook: <Parameters extends object, Success, Failure>(factory: EnsAtomFactory<Parameters, Success, Failure>) => <Mapped = Success>(input: UseEnsSuspenseAtomParameters<Parameters, Success, Failure, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 //#endregion
-export { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters, makeSuspenseQueryHook };
+export { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters, makeSuspenseQueryHook };
 //# sourceMappingURL=use-suspense-query.d.ts.map

package/dist/hooks/use-suspense-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-suspense-query.d.ts","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"mappings":";;;KAYY,8BAA8B,YAAY,SAAS,WAAW,WAAW;WAC1E,QAAQ,KAAK,gBAAgB,SAAS;;UAGhC,uBAAuB;WAC7B,MAAM;WACN;WACA;;cAGE,wBACV,2BAA2B,SAAS,SACnC,SAAS,oBAAoB,YAAY,SAAS,cAEnD,WAAW,SACV,OAAO,8BAA8B,YAAY,SAAS,cACzD,uBAAuB"}
+{"version":3,"file":"use-suspense-query.d.ts","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"mappings":";;;KAYY,6BACV,YACA,SACA,SACA,SAAS,WACP;WACO,OAAO,eAAe;WACtB,OAAO,OAAO,YAAY;;UAGpB,sBAAsB;WAC5B,MAAM;WACN;WACA;;cAGE,wBACV,2BAA2B,SAAS,SACnC,SAAS,eAAe,YAAY,SAAS,cAE9C,SAAS,SACR,OAAO,6BAA6B,YAAY,SAAS,SAAS,YACjE,sBAAsB"}