@peers-app/peers-ui 0.26.6 → 0.27.1

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./use-observable";
+export * from "./use-observable-state";
+export * from "./use-on-screen";
+export * from "./use-promise";
+export * from "./use-rows";
+export * from "./use-subscription";
+export * from "./use-tool";

package/dist/hooks/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `use-host-contract` stays internal: its screens import it by path.
+__exportStar(require("./use-observable"), exports);
+__exportStar(require("./use-observable-state"), exports);
+__exportStar(require("./use-on-screen"), exports);
+__exportStar(require("./use-promise"), exports);
+__exportStar(require("./use-rows"), exports);
+__exportStar(require("./use-subscription"), exports);
+__exportStar(require("./use-tool"), exports);

package/dist/hooks/use-observable-state.d.ts

@@ -0,0 +1,12 @@
+import { type Observable } from "@peers-app/peers-sdk";
+/**
+ * Use this to create an observable in a functional component.
+ * This automatically subscribes to the observable and triggers a re-render when the value changes.
+ * @param initialValue This will be the initial value of the observable
+ * @param doNotSubscribe If true, the observable will not be subscribed to automatically.
+ * This is useful if you want to create an observable that persists between rerenders but doesn't cause rerenders itself.
+ * @returns The same observable on every render.
+ */
+export declare function useObservableState<T>(initialValue: T, doNotSubscribe?: boolean): Observable<T>;
+/** Create an observable that may start undefined and subscribe unless `doNotSubscribe` is true. */
+export declare function useObservableState<T = undefined>(initialValue?: T, doNotSubscribe?: boolean): Observable<T | undefined>;

package/dist/hooks/use-observable-state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useObservableState = useObservableState;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const react_1 = require("react");
+const use_observable_1 = require("./use-observable");
+/** Create and optionally subscribe to a component-owned observable. */
+function useObservableState(initialValue, doNotSubscribe) {
+    const [obs] = (0, react_1.useState)(() => initialValue !== undefined ? (0, peers_sdk_1.observable)(initialValue) : (0, peers_sdk_1.observable)());
+    if (!doNotSubscribe) {
+        // biome-ignore lint/correctness/useHookAtTopLevel: when doNotSubscribe, caller keeps a stable observable without React-driven subscription (see docstring).
+        (0, use_observable_1.useObservable)(obs);
+    }
+    return obs;
+}

package/dist/hooks/use-observable-state.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@testing-library/react");
+const use_observable_1 = require("./use-observable");
+const use_observable_state_1 = require("./use-observable-state");
+// Helper component to test useObservableState
+function ObservableStateTestComponent({ initialValue }) {
+    const obs = (0, use_observable_state_1.useObservableState)(initialValue);
+    const [value] = (0, use_observable_1.useObservable)(obs);
+    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "state-value", children: value }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "increment", onClick: () => obs(obs() + 1), children: "Increment" })] }));
+}
+describe("useObservableState", () => {
+    it("should create an observable with the initial value", () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(ObservableStateTestComponent, { initialValue: 42 }));
+        expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("42");
+    });
+    it("should re-render when the observable is updated", async () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(ObservableStateTestComponent, { initialValue: 0 }));
+        expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("0");
+        (0, react_1.act)(() => {
+            react_1.screen.getByTestId("increment").click();
+        });
+        await (0, react_1.waitFor)(() => {
+            expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("1");
+        });
+    });
+    it("should maintain the same observable instance across re-renders", async () => {
+        let capturedObs = null;
+        function CaptureObsComponent() {
+            const obs = (0, use_observable_state_1.useObservableState)(0);
+            if (!capturedObs) {
+                capturedObs = obs;
+            }
+            const [value] = (0, use_observable_1.useObservable)(obs);
+            return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "value", children: value }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "same-obs", children: obs === capturedObs ? "same" : "different" }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "update", onClick: () => obs(obs() + 1), children: "Update" })] }));
+        }
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(CaptureObsComponent, {}));
+        expect(react_1.screen.getByTestId("same-obs")).toHaveTextContent("same");
+        // Trigger a re-render by updating the observable
+        (0, react_1.act)(() => {
+            react_1.screen.getByTestId("update").click();
+        });
+        await (0, react_1.waitFor)(() => {
+            expect(react_1.screen.getByTestId("value")).toHaveTextContent("1");
+            expect(react_1.screen.getByTestId("same-obs")).toHaveTextContent("same");
+        });
+    });
+    it("should not subscribe when doNotSubscribe is true", () => {
+        function NoSubscribeComponent() {
+            const obs = (0, use_observable_state_1.useObservableState)(0, true); // doNotSubscribe = true
+            return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "value", children: obs() }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "update", onClick: () => obs(obs() + 1), children: "Update" })] }));
+        }
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(NoSubscribeComponent, {}));
+        expect(react_1.screen.getByTestId("value")).toHaveTextContent("0");
+        // Update won't cause re-render since we're not subscribed
+        (0, react_1.act)(() => {
+            react_1.screen.getByTestId("update").click();
+        });
+        // Value in DOM should still show 0 since component didn't re-render
+        // But the observable itself has been updated
+        expect(react_1.screen.getByTestId("value")).toHaveTextContent("0");
+    });
+});

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

@@ -0,0 +1,8 @@
+import { type Observable, type ReadonlyObservable } from "@peers-app/peers-sdk";
+import type React from "react";
+/** Read and subscribe to a writable observable, with a setter for its value. */
+export declare function useObservable<T>(sub: Observable<T>, deps?: React.DependencyList): [T, (value: T) => void];
+/** Read and subscribe to a read-only observable; its setter accepts no values. */
+export declare function useObservable<T>(sub: ReadonlyObservable<T>, deps?: React.DependencyList): [T, (value: never) => void];
+/** Read a plain value or a writable observable, retaining the existing optional-observable API. */
+export declare function useObservable<T>(sub: Observable<T> | T, deps?: React.DependencyList): [T, (value: T) => void];

package/dist/hooks/use-observable.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useObservable = useObservable;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const react_1 = require("react");
+/**
+ * Subscribe to an observable or computed in a functional component, using useSyncExternalStore
+ * for React 18 concurrent rendering. Only writable observables have a callable typed setter.
+ * @param sub the observable, computed, or plain value to read
+ * @param deps dependencies that cause re-subscription when changed
+ */
+function useObservable(sub, deps = []) {
+    // Create memoized subscribe function that adapts Observable's subscribe API to useSyncExternalStore's expected signature
+    const subscribe = (0, react_1.useCallback)((onStoreChange) => {
+        if (!(0, peers_sdk_1.isSubscribable)(sub)) {
+            // If not subscribable, return a no-op unsubscribe
+            return () => { };
+        }
+        const subscription = sub.subscribe(onStoreChange);
+        return () => subscription.dispose();
+    }, [sub, ...deps]);
+    // getSnapshot returns the current value from the observable
+    const getSnapshot = (0, react_1.useCallback)(() => {
+        return (0, peers_sdk_1.unwrapObservable)(sub);
+    }, [sub, ...deps]);
+    // Use useSyncExternalStore for concurrent-safe subscription
+    const data = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    // Create setter that updates both local understanding and the observable
+    const setter = (0, react_1.useCallback)((newData) => {
+        if ((0, peers_sdk_1.isSubscribable)(sub)) {
+            sub(newData);
+        }
+    }, [sub]);
+    return [data, setter];
+}

package/dist/hooks/use-observable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{hooks.test.js → hooks/use-observable.test.js}

@@ -3,24 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
 const peers_sdk_1 = require("@peers-app/peers-sdk");
 const react_1 = require("@testing-library/react");
-const hooks_1 = require("./hooks");
+const use_observable_1 = require("./use-observable");
 // Helper component to test useObservable
 function TestComponent({ obs, testId = "value" }) {
-    const [value, setValue] = (0, hooks_1.useObservable)(obs);
+    const [value, setValue] = (0, use_observable_1.useObservable)(obs);
     return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": testId, children: JSON.stringify(value) }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "setter", onClick: () => setValue("new-value"), children: "Set" })] }));
 }
 // Helper component to test array behavior
 function ArrayTestComponent({ obs }) {
-    const [value] = (0, hooks_1.useObservable)(obs);
+    const [value] = (0, use_observable_1.useObservable)(obs);
     return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "array-value", children: JSON.stringify(value) }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "array-length", children: value.length })] }));
 }
-// Helper component to test useObservableState
-function ObservableStateTestComponent({ initialValue }) {
-    const obs = (0, hooks_1.useObservableState)(initialValue);
-    const [value] = (0, hooks_1.useObservable)(obs);
-    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "state-value", children: value }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "increment", onClick: () => obs(obs() + 1), children: "Increment" })] }));
-}
 describe("useObservable", () => {
+    it("reads and follows a read-only observable without allowing typed writes", () => {
+        const source = (0, peers_sdk_1.observable)(1);
+        const view = source;
+        const { result } = (0, react_1.renderHook)(() => (0, use_observable_1.useObservable)(view));
+        const checkReadonly = () => {
+            // @ts-expect-error the read-only hook's setter accepts no values
+            result.current[1](2);
+            if ((0, peers_sdk_1.isSubscribable)(view)) {
+                // @ts-expect-error testing subscribability must not make a read-only view writable
+                view(2);
+            }
+        };
+        void checkReadonly;
+        const initial = result.current[0];
+        expect(initial).toBe(1);
+        (0, react_1.act)(() => source(3));
+        expect(result.current[0]).toBe(3);
+    });
     describe("basic functionality", () => {
         it("should return the current value of an observable", () => {
             const obs = (0, peers_sdk_1.observable)("hello");
@@ -162,7 +174,7 @@ describe("useObservable", () => {
         it("should handle rapid sequential updates correctly", async () => {
             const obs = (0, peers_sdk_1.observable)(0);
             function CounterComponent() {
-                const [value] = (0, hooks_1.useObservable)(obs);
+                const [value] = (0, use_observable_1.useObservable)(obs);
                 return (0, jsx_runtime_1.jsx)("span", { "data-testid": "counter", children: value });
             }
             (0, react_1.render)((0, jsx_runtime_1.jsx)(CounterComponent, {}));
@@ -177,55 +189,3 @@ describe("useObservable", () => {
         });
     });
 });
-describe("useObservableState", () => {
-    it("should create an observable with the initial value", () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(ObservableStateTestComponent, { initialValue: 42 }));
-        expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("42");
-    });
-    it("should re-render when the observable is updated", async () => {
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(ObservableStateTestComponent, { initialValue: 0 }));
-        expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("0");
-        (0, react_1.act)(() => {
-            react_1.screen.getByTestId("increment").click();
-        });
-        await (0, react_1.waitFor)(() => {
-            expect(react_1.screen.getByTestId("state-value")).toHaveTextContent("1");
-        });
-    });
-    it("should maintain the same observable instance across re-renders", async () => {
-        let capturedObs = null;
-        function CaptureObsComponent() {
-            const obs = (0, hooks_1.useObservableState)(0);
-            if (!capturedObs) {
-                capturedObs = obs;
-            }
-            const [value] = (0, hooks_1.useObservable)(obs);
-            return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "value", children: value }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "same-obs", children: obs === capturedObs ? "same" : "different" }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "update", onClick: () => obs(obs() + 1), children: "Update" })] }));
-        }
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(CaptureObsComponent, {}));
-        expect(react_1.screen.getByTestId("same-obs")).toHaveTextContent("same");
-        // Trigger a re-render by updating the observable
-        (0, react_1.act)(() => {
-            react_1.screen.getByTestId("update").click();
-        });
-        await (0, react_1.waitFor)(() => {
-            expect(react_1.screen.getByTestId("value")).toHaveTextContent("1");
-            expect(react_1.screen.getByTestId("same-obs")).toHaveTextContent("same");
-        });
-    });
-    it("should not subscribe when doNotSubscribe is true", () => {
-        function NoSubscribeComponent() {
-            const obs = (0, hooks_1.useObservableState)(0, true); // doNotSubscribe = true
-            return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "value", children: obs() }), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-testid": "update", onClick: () => obs(obs() + 1), children: "Update" })] }));
-        }
-        (0, react_1.render)((0, jsx_runtime_1.jsx)(NoSubscribeComponent, {}));
-        expect(react_1.screen.getByTestId("value")).toHaveTextContent("0");
-        // Update won't cause re-render since we're not subscribed
-        (0, react_1.act)(() => {
-            react_1.screen.getByTestId("update").click();
-        });
-        // Value in DOM should still show 0 since component didn't re-render
-        // But the observable itself has been updated
-        expect(react_1.screen.getByTestId("value")).toHaveTextContent("0");
-    });
-});

package/dist/hooks/use-on-screen.d.ts

@@ -0,0 +1,3 @@
+import type React from "react";
+/** Track whether the referenced element intersects the viewport. */
+export declare function useOnScreen(ref: React.RefObject<Element | null>): boolean;

package/dist/hooks/use-on-screen.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnScreen = useOnScreen;
+const react_1 = require("react");
+/** Track whether the referenced element intersects the viewport. */
+function useOnScreen(ref) {
+    const [isIntersecting, setIntersecting] = (0, react_1.useState)(false);
+    // Read ref.current once on mount (ref object identity is stable).
+    (0, react_1.useEffect)(() => {
+        const element = ref.current;
+        if (!element) {
+            return;
+        }
+        const observer = new IntersectionObserver(([entry]) => {
+            setIntersecting(entry.isIntersecting);
+        });
+        observer.observe(element);
+        return () => {
+            observer.disconnect();
+        };
+    }, []);
+    return isIntersecting;
+}

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

@@ -0,0 +1,9 @@
+import type React from "react";
+/**
+ * Use this to easily wait for a promise in a functional component.
+ * @param p The promise to wait for
+ * @param initialValue the initial value to return before the promise resolves
+ * @param deps the dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the initial value and the resolved value of the promise
+ */
+export declare function usePromise<T>(p: Promise<T> | (() => Promise<T>), initialValue?: T, deps?: React.DependencyList): T | undefined;

package/dist/hooks/use-promise.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePromise = usePromise;
+const react_1 = require("react");
+/**
+ * Use this to easily wait for a promise in a functional component.
+ * @param p The promise to wait for
+ * @param initialValue the initial value to return before the promise resolves
+ * @param deps the dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the initial value and the resolved value of the promise
+ */
+function usePromise(p, initialValue, deps = []) {
+    const [data, setData] = (0, react_1.useState)(initialValue);
+    // `deps` drives when the effect re-runs; callers include `p` when it changes. Omitting `p` avoids duplicate tracking with `[...deps]`.
+    (0, react_1.useEffect)(() => {
+        let disposed = false;
+        if (typeof p === "function") {
+            p = p();
+        }
+        p.then((newData) => {
+            // if (!_.isEqual(newData, data) && !disposed) {
+            if (!disposed) {
+                setData(newData);
+            }
+        });
+        return () => {
+            disposed = true;
+        };
+    }, [...deps]);
+    return data;
+}

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

@@ -0,0 +1,42 @@
+import type { DataFilter, IDataQueryParams, IHostSubscribeOptions, ISubscriptionResult } from "@peers-app/peers-sdk";
+/** A table `useRows` can read: a `hostContract` table, or anything with the same two members. */
+export interface IRowsSource<T extends Record<string, any>> {
+    /** Rows matching `filter`, with paging and sorting options. */
+    list(filter?: DataFilter<T>, options?: IDataQueryParams<T>): Promise<T[]>;
+    /**
+     * Changes to the rows. Optional `ready` acknowledges remote attachment; `onReconnect` runs
+     * once a replacement subscription is live, when changes may have been missed.
+     */
+    readonly dataChanged: {
+        subscribe(handler: (event: unknown) => void, options?: IHostSubscribeOptions): ISubscriptionResult & {
+            readonly ready?: Promise<boolean>;
+        };
+    };
+}
+/** What {@link useRows} returns. */
+export interface IUseRowsResult<T> {
+    /** The latest rows; empty until the first read. */
+    rows: T[];
+    /** True until a read settles after mounting or after the query changed. */
+    loading: boolean;
+    /** Why the latest read failed; cleared by the next one that succeeds. */
+    error: Error | undefined;
+    /** Read again now. Resolves when the rows are current. */
+    reload(): Promise<void>;
+}
+/**
+ * Rows from a contract table, kept current: read on mount, and read again whenever the table
+ * changes, once an asynchronous subscription is live, after a reconnect, or when `filter` or
+ * `options` change (compared as JSON). Changes
+ * that arrive during a read cause one more read, not one per change.
+ *
+ * ```tsx
+ * const { rows: headlines, error } = useRows(news.tables.Headlines, {}, { pageSize: 100 });
+ * ```
+ *
+ * @param table - A table from a `hostContract` client. Keep it stable (make the client once, at
+ *   module scope, as `hostContract` does): a new table reads and subscribes again.
+ * @param filter - Which rows (all when omitted).
+ * @param options - Paging and sorting.
+ */
+export declare function useRows<T extends Record<string, any>>(table: IRowsSource<T>, filter?: DataFilter<T>, options?: IDataQueryParams<T>): IUseRowsResult<T>;

package/dist/hooks/use-rows.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRows = useRows;
+const react_1 = require("react");
+/**
+ * Rows from a contract table, kept current: read on mount, and read again whenever the table
+ * changes, once an asynchronous subscription is live, after a reconnect, or when `filter` or
+ * `options` change (compared as JSON). Changes
+ * that arrive during a read cause one more read, not one per change.
+ *
+ * ```tsx
+ * const { rows: headlines, error } = useRows(news.tables.Headlines, {}, { pageSize: 100 });
+ * ```
+ *
+ * @param table - A table from a `hostContract` client. Keep it stable (make the client once, at
+ *   module scope, as `hostContract` does): a new table reads and subscribes again.
+ * @param filter - Which rows (all when omitted).
+ * @param options - Paging and sorting.
+ */
+function useRows(table, filter, options) {
+    const key = JSON.stringify([filter ?? {}, options ?? {}]);
+    const query = (0, react_1.useRef)({ filter, options });
+    query.current = { filter, options };
+    const [state, setState] = (0, react_1.useState)({
+        rows: [],
+        loading: true,
+    });
+    const reloadRef = (0, react_1.useRef)(async () => undefined);
+    // `key` stands for filter and options, which the reads take from `query`.
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        let again = false;
+        let reading;
+        let subscription;
+        setState((previous) => (previous.loading ? previous : { ...previous, loading: true }));
+        const read = () => {
+            again = true;
+            reading ??= Promise.resolve().then(async () => {
+                try {
+                    while (again && !cancelled) {
+                        again = false;
+                        try {
+                            if (!subscription) {
+                                subscription = table.dataChanged.subscribe(readAgain, { onReconnect: readAgain });
+                                // Read again after remote attachment, covering changes missed during setup
+                                // without delaying the initial read's connection timeout.
+                                void subscription.ready?.then((live) => {
+                                    if (live && !cancelled)
+                                        readAgain();
+                                });
+                            }
+                            const rows = await table.list(query.current.filter, query.current.options);
+                            if (!cancelled) {
+                                setState({ rows: Array.isArray(rows) ? rows : [], loading: false });
+                            }
+                        }
+                        catch (cause) {
+                            if (!cancelled) {
+                                const error = cause instanceof Error ? cause : new Error(String(cause));
+                                setState((previous) => ({ rows: previous.rows, loading: false, error }));
+                            }
+                        }
+                    }
+                }
+                finally {
+                    reading = undefined;
+                }
+            });
+            return reading;
+        };
+        const readAgain = () => {
+            void read();
+        };
+        reloadRef.current = read;
+        readAgain();
+        return () => {
+            cancelled = true;
+            subscription?.unsubscribe();
+        };
+    }, [table, key]);
+    const reload = (0, react_1.useCallback)(() => reloadRef.current(), []);
+    return { rows: state.rows, loading: state.loading, error: state.error, reload };
+}

package/dist/hooks/use-rows.test.d.ts

@@ -0,0 +1 @@
+export {};