lemma-sdk 0.2.30 → 0.2.31

package/dist/react/useRecord.js

@@ -1,14 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { normalizeError, resolvePodClient } from "./utils.js";
 export function useRecord({ client, podId, tableName, recordId = null, enabled = true, autoLoad = true, }) {
     const [record, setRecord] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
@@ -16,7 +7,7 @@ export function useRecord({ client, podId, tableName, recordId = null, enabled =
     const trimmedTableName = tableName.trim();
     const trimmedRecordId = typeof recordId === "string" ? recordId.trim() : "";
     const isEnabled = enabled && trimmedTableName.length > 0 && trimmedRecordId.length > 0;
-    const refresh = useCallback(async (overrides = {}) => {
+    const refresh = useCallback(async (overrides = {}, signal) => {
         const nextRecordId = typeof overrides.recordId === "string"
             ? overrides.recordId.trim()
             : trimmedRecordId;
@@ -31,17 +22,22 @@ export function useRecord({ client, podId, tableName, recordId = null, enabled =
         try {
             const scopedClient = resolvePodClient(client, podId);
             const response = await scopedClient.records.get(trimmedTableName, nextRecordId);
+            if (signal?.aborted)
+                return null;
             const nextRecord = (response.data ?? null);
             setRecord(nextRecord);
             return nextRecord;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return null;
             const normalized = normalizeError(refreshError, "Failed to load record.");
             setError(normalized);
             return null;
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [client, enabled, podId, trimmedRecordId, trimmedTableName]);
     useEffect(() => {
@@ -53,7 +49,22 @@ export function useRecord({ client, podId, tableName, recordId = null, enabled =
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load record."), "Failed to load record."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, isEnabled, refresh]);
     return useMemo(() => ({
         record,

package/dist/react/useRecordForm.js

@@ -1,25 +1,8 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildRecordFormValues, buildRecordPayload, } from "../record-form.js";
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
 import { useRecordSchema, } from "./useRecordSchema.js";
 const EMPTY_VALUES = {};
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function stringifyComparable(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
 export function useRecordForm({ client, podId, tableName, recordId = null, initialValues = EMPTY_VALUES, mode = "auto", enabled = true, autoLoad = true, onSubmitSuccess, onError, }) {
     const schema = useRecordSchema({
         client,

package/dist/react/useRecords.d.ts

@@ -12,7 +12,9 @@ export interface UseRecordsResult<TRecord extends Record<string, unknown> = Reco
     total: number;
     nextPageToken: string | null;
     isLoading: boolean;
+    isLoadingMore: boolean;
     error: Error | null;
     refresh: (overrides?: Partial<ListRecordsOptions>) => Promise<TRecord[]>;
+    loadMore: (overrides?: Partial<ListRecordsOptions>) => Promise<TRecord[]>;
 }
 export declare function useRecords<TRecord extends Record<string, unknown> = Record<string, unknown>>({ client, podId, tableName, filters, sort, limit, pageToken, offset, sortBy, order, params, enabled, autoLoad, }: UseRecordsOptions): UseRecordsResult<TRecord>;

package/dist/react/useRecords.js

@@ -1,27 +1,11 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
-function stringifyComparable(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
 export function useRecords({ client, podId, tableName, filters, sort, limit = 20, pageToken, offset, sortBy, order, params, enabled = true, autoLoad = true, }) {
     const [records, setRecords] = useState([]);
     const [total, setTotal] = useState(0);
     const [nextPageToken, setNextPageToken] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
     const [error, setError] = useState(null);
     const trimmedTableName = tableName.trim();
     const isEnabled = enabled && trimmedTableName.length > 0;
@@ -31,7 +15,7 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
     const stableFilters = useMemo(() => filters, [filtersKey]);
     const stableSort = useMemo(() => sort, [sortKey]);
     const stableParams = useMemo(() => params, [paramsKey]);
-    const refresh = useCallback(async (overrides = {}) => {
+    const refresh = useCallback(async (overrides = {}, signal) => {
         if (!isEnabled) {
             setRecords([]);
             setTotal(0);
@@ -54,6 +38,8 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
                 order: overrides.order ?? order,
                 params: overrides.params ?? stableParams,
             });
+            if (signal?.aborted)
+                return [];
             const nextRecords = (response.items ?? []);
             setRecords(nextRecords);
             setTotal(response.total ?? nextRecords.length);
@@ -61,12 +47,15 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
             return nextRecords;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return [];
             const normalized = normalizeError(refreshError, "Failed to load records.");
             setError(normalized);
             return [];
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [
         client,
@@ -82,6 +71,39 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         stableSort,
         trimmedTableName,
     ]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!isEnabled || !nextPageToken || isLoading || isLoadingMore) {
+            return [];
+        }
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.records.list(trimmedTableName, {
+                filters: stableFilters,
+                sort: stableSort,
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+                offset: overrides.offset,
+                sortBy: overrides.sortBy ?? sortBy,
+                order: overrides.order ?? order,
+                params: overrides.params ?? stableParams,
+            });
+            const moreRecords = (response.items ?? []);
+            setRecords((previous) => [...previous, ...moreRecords]);
+            setTotal(response.total ?? records.length + moreRecords.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreRecords;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more records.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, trimmedTableName]);
     useEffect(() => {
         if (!isEnabled) {
             setRecords([]);
@@ -89,18 +111,36 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
             setNextPageToken(null);
             setError(null);
             setIsLoading(false);
+            setIsLoadingMore(false);
             return;
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load records."), "Failed to load records."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, isEnabled, refresh]);
     return useMemo(() => ({
         records,
         total,
         nextPageToken,
         isLoading,
+        isLoadingMore,
         error,
         refresh,
-    }), [error, isLoading, nextPageToken, records, refresh, total]);
+        loadMore,
+    }), [error, isLoading, isLoadingMore, loadMore, nextPageToken, records, refresh, total]);
 }

package/dist/react/useRelatedRecords.js

@@ -1,23 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildJoinedRecordsQuery, parseForeignKeyReference } from "../datastore-query.js";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
-function stringifyComparable(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
 function sentenceCase(value) {
     return value
         .replace(/[_\.]/g, " ")
@@ -82,7 +65,7 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
     const stableInclude = useMemo(() => include, [includeKey]);
     const stableBaseFields = useMemo(() => baseFields, [baseFieldsKey]);
     const isEnabled = enabled && trimmedTableName.length > 0 && stableInclude.length > 0;
-    const refresh = useCallback(async () => {
+    const refresh = useCallback(async (signal) => {
         if (!isEnabled) {
             setRecords([]);
             setColumns([]);
@@ -98,6 +81,8 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
         try {
             const scopedClient = resolvePodClient(client, podId);
             const nextBaseTable = await scopedClient.tables.get(trimmedTableName);
+            if (signal?.aborted)
+                return [];
             if (nextBaseTable.enable_rls) {
                 throw new Error(`Related record queries are not supported for RLS-enabled table "${trimmedTableName}". Use table-scoped record APIs instead.`);
             }
@@ -105,6 +90,8 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
             const resolvedBaseFields = (stableBaseFields?.length ? stableBaseFields : pickDefaultBaseFields(nextBaseTable))
                 .filter((field, index, allFields) => field.trim().length > 0 && allFields.indexOf(field) === index);
             const resolvedIncludes = await Promise.all(stableInclude.map(async (entry, index) => {
+                if (signal?.aborted)
+                    throw new Error("Aborted");
                 const baseColumn = nextBaseTable.columns.find((column) => column.name === entry.foreignKey) ?? null;
                 const reference = baseColumn?.foreign_key?.references
                     ? parseForeignKeyReference(baseColumn.foreign_key.references)
@@ -163,6 +150,8 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
             setSql(nextSql);
             setIncludes(resolvedIncludes.map(({ alias: _alias, ...rest }) => rest));
             const response = await scopedClient.datastore.query(nextSql);
+            if (signal?.aborted)
+                return [];
             const nextColumns = [
                 ...resolvedBaseFields.map((field) => ({
                     key: field,
@@ -196,12 +185,15 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
             return nextRecords;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return [];
             const normalized = normalizeError(refreshError, "Failed to load related records.");
             setError(normalized);
             return [];
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [client, isEnabled, limit, offset, podId, stableBaseFields, stableInclude, trimmedTableName]);
     useEffect(() => {
@@ -217,7 +209,22 @@ export function useRelatedRecords({ client, podId, tableName, baseFields, includ
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load related records."), "Failed to load related records."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, isEnabled, refresh]);
     return useMemo(() => ({
         records,

package/dist/react/useReverseRelatedRecords.js

@@ -1,23 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { parseForeignKeyReference } from "../datastore-query.js";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
-function stringifyComparable(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
 function sentenceCase(value) {
     return value
         .replace(/[_\.]/g, " ")
@@ -62,7 +45,7 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
     const stableRelation = useMemo(() => relation, [relationKey]);
     const stableFields = useMemo(() => fields, [fieldsKey]);
     const isEnabled = enabled && trimmedTableName.length > 0 && trimmedRecordId.length > 0;
-    const refresh = useCallback(async () => {
+    const refresh = useCallback(async (signal) => {
         if (!isEnabled) {
             setParentTable(null);
             setRelatedTable(null);
@@ -85,10 +68,14 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
                 scopedClient.tables.list({ limit: tablesLimit }),
                 scopedClient.records.get(trimmedTableName, trimmedRecordId),
             ]);
+            if (signal?.aborted)
+                return [];
             const listedTables = tablesResponse.items ?? [];
             const nextParentTable = listedTables.find((tableEntry) => tableEntry.name === trimmedTableName)
                 ?? await scopedClient.tables.get(trimmedTableName);
             const nextParentRecord = parentRecordResponse.data ?? null;
+            if (signal?.aborted)
+                return [];
             setParentTable(nextParentTable);
             setParentRecord(nextParentRecord);
             const nextRelations = listedTables.flatMap((candidateTable) => candidateTable.columns.flatMap((column) => {
@@ -123,6 +110,8 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
                 ?? await scopedClient.tables.get(nextSelectedRelation.tableName);
             const referenceValue = nextParentRecord?.[nextSelectedRelation.referencedColumn]
                 ?? (nextSelectedRelation.referencedColumn === "id" ? trimmedRecordId : undefined);
+            if (signal?.aborted)
+                return [];
             setRelatedTable(nextRelatedTable);
             if (typeof referenceValue === "undefined" || referenceValue === null) {
                 setColumns([]);
@@ -144,6 +133,8 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
                 sortBy,
                 order,
             });
+            if (signal?.aborted)
+                return [];
             const nextRecords = (response.items ?? []);
             setColumns(resolvedFields.map((field) => ({
                 key: field,
@@ -156,12 +147,15 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
             return nextRecords;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return [];
             const normalized = normalizeError(refreshError, "Failed to load reverse-related records.");
             setError(normalized);
             return [];
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [
         client,
@@ -194,7 +188,22 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load reverse-related records."), "Failed to load reverse-related records."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, isEnabled, refresh]);
     return useMemo(() => ({
         parentTable,

package/dist/react/useSchemaForm.js

@@ -1,18 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildSchemaFormFields, buildSchemaFormPayload, buildSchemaFormValues, } from "../schema-form.js";
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
-function stringifyComparable(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
+import { normalizeError, stringifyComparable } from "./utils.js";
 const EMPTY_VALUES = {};
 export function useSchemaForm({ schema = null, uiSchema = null, initialValues = EMPTY_VALUES, enabled = true, onSubmit, onError, }) {
     const [values, setValuesState] = useState({});

package/dist/react/useTable.js

@@ -1,21 +1,12 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { normalizeError, resolvePodClient } from "./utils.js";
 export function useTable({ client, podId, tableName, enabled = true, autoLoad = true, }) {
     const [table, setTable] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const trimmedTableName = tableName.trim();
     const isEnabled = enabled && trimmedTableName.length > 0;
-    const refresh = useCallback(async () => {
+    const refresh = useCallback(async (signal) => {
         if (!isEnabled) {
             setTable(null);
             setError(null);
@@ -27,16 +18,21 @@ export function useTable({ client, podId, tableName, enabled = true, autoLoad =
         try {
             const scopedClient = resolvePodClient(client, podId);
             const nextTable = await scopedClient.tables.get(trimmedTableName);
+            if (signal?.aborted)
+                return null;
             setTable(nextTable);
             return nextTable;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return null;
             const normalized = normalizeError(refreshError, "Failed to load table.");
             setError(normalized);
             return null;
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [client, isEnabled, podId, trimmedTableName]);
     useEffect(() => {
@@ -48,7 +44,22 @@ export function useTable({ client, podId, tableName, enabled = true, autoLoad =
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load table."), "Failed to load table."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, isEnabled, refresh]);
     return useMemo(() => ({
         table,

package/dist/react/useTables.d.ts

@@ -13,10 +13,14 @@ export interface UseTablesResult {
     total: number;
     nextPageToken: string | null;
     isLoading: boolean;
+    isLoadingMore: boolean;
     error: Error | null;
     refresh: (overrides?: {
         limit?: number;
         pageToken?: string;
     }) => Promise<Table[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<Table[]>;
 }
 export declare function useTables({ client, podId, enabled, autoLoad, limit, pageToken, }: UseTablesOptions): UseTablesResult;

package/dist/react/useTables.js

@@ -1,21 +1,13 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { normalizeError, resolvePodClient } from "./utils.js";
 export function useTables({ client, podId, enabled = true, autoLoad = true, limit = 100, pageToken, }) {
     const [tables, setTables] = useState([]);
     const [total, setTotal] = useState(0);
     const [nextPageToken, setNextPageToken] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
     const [error, setError] = useState(null);
-    const refresh = useCallback(async (overrides = {}) => {
+    const refresh = useCallback(async (overrides = {}, signal) => {
         if (!enabled) {
             setTables([]);
             setTotal(0);
@@ -32,21 +24,53 @@ export function useTables({ client, podId, enabled = true, autoLoad = true, limi
                 limit: overrides.limit ?? limit,
                 pageToken: overrides.pageToken ?? pageToken,
             });
+            if (signal?.aborted)
+                return [];
             const nextTables = response.items ?? [];
             setTables(nextTables);
-            setTotal(nextTables.length);
+            setTotal(response.total ?? nextTables.length);
             setNextPageToken(response.next_page_token ?? null);
             return nextTables;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return [];
             const normalized = normalizeError(refreshError, "Failed to load tables.");
             setError(normalized);
             return [];
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [client, enabled, limit, pageToken, podId]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!enabled || !nextPageToken || isLoading || isLoadingMore) {
+            return [];
+        }
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.tables.list({
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+            });
+            const moreTables = response.items ?? [];
+            setTables((previous) => [...previous, ...moreTables]);
+            setTotal(response.total ?? tables.length + moreTables.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreTables;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more tables.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, enabled, isLoading, isLoadingMore, limit, nextPageToken, podId, tables.length]);
     useEffect(() => {
         if (!enabled) {
             setTables([]);
@@ -54,18 +78,36 @@ export function useTables({ client, podId, enabled = true, autoLoad = true, limi
             setNextPageToken(null);
             setError(null);
             setIsLoading(false);
+            setIsLoadingMore(false);
             return;
         }
         if (!autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load tables."), "Failed to load tables."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, enabled, refresh]);
     return useMemo(() => ({
         tables,
         total,
         nextPageToken,
         isLoading,
+        isLoadingMore,
         error,
         refresh,
-    }), [error, isLoading, nextPageToken, refresh, tables, total]);
+        loadMore,
+    }), [error, isLoading, isLoadingMore, loadMore, nextPageToken, refresh, tables, total]);
 }