shelving 1.268.1 → 1.268.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.268.1",
+	"version": "1.268.2",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/react/createAPIContext.d.ts

@@ -1,5 +1,6 @@
 import { type ReactElement } from "react";
 import type { Endpoint } from "../api/endpoint/Endpoint.js";
+import { APICache } from "../api/index.js";
 import type { APIProvider } from "../api/provider/APIProvider.js";
 import type { EndpointStore } from "../api/store/EndpointStore.js";
 import type { ChildProps } from "../ui/index.js";
@@ -13,8 +14,10 @@ export interface APIContext<P, R> {
     /** React hook to return an `EndpointStore` for the specified endpoint/payload in the current `APIProvider` context. */
     useAPI<PP extends P, RR extends R>(this: void, endpoint: Endpoint<PP, RR>, payload: PP): EndpointStore<PP, RR>;
     useAPI<PP extends P, RR extends R>(this: void, endpoint: Nullish<Endpoint<PP, RR>>, payload: PP): EndpointStore<PP, RR> | undefined;
-    /** The `<APIContext>` wrapper to give your React components access to this API provider. */
+    /** Create a new `APICache` and provide it as context to child nodes, to allow them to use `useAPI()` */
     readonly APIContext: (props: ChildProps) => ReactElement;
+    /** Return the underlying `APICache` for `<APIContext>` */
+    requireAPICache(): APICache<P, R>;
 }
 /**
  * Create an API context.

package/react/createAPIContext.js

@@ -15,15 +15,18 @@ import { useStore } from "./useStore.js";
  */
 export function createAPIContext(provider) {
     const CacheContext = createContext(undefined);
-    function useAPI(endpoint, payload) {
+    function requireAPICache(caller = requireAPICache) {
         const cache = use(CacheContext);
         if (!cache)
-            throw new RequiredError(`useAPI() can only be used inside <APIContext>`, { caller: useAPI });
-        return useStore(endpoint ? cache.get(endpoint).get(payload) : undefined);
+            throw new RequiredError(`Must be used inside <APIContext>`, { caller });
+        return cache;
+    }
+    function useAPI(endpoint, payload) {
+        return useStore(endpoint ? requireAPICache(useAPI).get(endpoint).get(payload) : undefined);
     }
     function APIContext({ children }) {
         const cache = useInstance(APICache, provider);
         return _jsx(CacheContext, { value: cache, children: children });
     }
-    return { useAPI, APIContext };
+    return { requireAPICache, useAPI, APIContext };
 }

package/react/createDBContext.d.ts

@@ -1,4 +1,5 @@
 import { type ReactElement, type ReactNode } from "react";
+import { DBCache } from "../db/cache/DBCache.js";
 import type { Collection } from "../db/collection/Collection.js";
 import type { DBProvider } from "../db/provider/DBProvider.js";
 import type { ItemStore } from "../db/store/ItemStore.js";
@@ -23,10 +24,12 @@ export interface DBContext<I extends Identifier, T extends Data> {
     query: Nullish<Query<Item<II, TT>>>): QueryStore<II, TT> | undefined;
     useQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, //
     query: Query<Item<II, TT>>): QueryStore<II, TT>;
-    /** The `<DataContext>` wrapper to give your React components access to this data. */
+    /** Create a new `DBCache` and provide it as context to child nodes, to allow them to use `useItem()` and `useQuery()` */
     readonly DBContext: ({ children }: {
         children: ReactNode;
     }) => ReactElement;
+    /** Return the underlying `DBCache` for `<DBContext>` */
+    requireDBCache(): DBCache<I, T>;
 }
 /**
  * Create a data context

package/react/createDBContext.js

@@ -15,23 +15,23 @@ import { useStore } from "./useStore.js";
  */
 export function createDBContext(provider) {
     const CacheContext = createContext(undefined);
-    function useItem(collection, //
-    id) {
+    function requireDBCache(caller = requireDBCache) {
         const cache = use(CacheContext);
         if (!cache)
-            throw new RequiredError("useItem() can only be used inside <DBContext>", { caller: useItem });
-        return useStore(collection && id ? cache.getItem(collection, id) : undefined);
+            throw new RequiredError(`Must be used inside <DBContext>`, { caller });
+        return cache;
+    }
+    function useItem(collection, //
+    id) {
+        return useStore(collection && id ? requireDBCache(useItem).getItem(collection, id) : undefined);
     }
     function useQuery(collection, //
     query) {
-        const cache = use(CacheContext);
-        if (!cache)
-            throw new RequiredError("useQuery() can only be used inside <DBContext>", { caller: useQuery });
-        return useStore(collection && query ? cache.getQuery(collection, query) : undefined);
+        return useStore(collection && query ? requireDBCache(useQuery).getQuery(collection, query) : undefined);
     }
     function DBContext({ children }) {
         const cache = useInstance(DBCache, provider);
         return _jsx(CacheContext, { value: cache, children: children });
     }
-    return { useItem, useQuery, DBContext };
+    return { requireDBCache, useItem, useQuery, DBContext };
 }