@vennbase/react 0.1.8

package/dist/index.js

@@ -0,0 +1,694 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { VENNBASE_INVITE_TARGET_PARAM } from "@vennbase/core";
+import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+import { getDefaultRuntime, getIdleSnapshot, makeShareLinkKey, makeIncomingInviteKey, makeMembersKey, makeSavedRowKey, makeParentsKey, makeQueryKey, makeRowKey, snapshots, } from "./runtime";
+import { VennbaseReactRuntime as Runtime } from "./runtime";
+const RuntimeContext = createContext(null);
+const noopSubscribe = () => () => undefined;
+const noopRefresh = async () => undefined;
+const noopFlush = async () => undefined;
+function makeResourceResult(snapshot, refresh = noopRefresh) {
+    return {
+        data: snapshot.data,
+        error: snapshot.error,
+        refreshError: snapshot.refreshError,
+        isRefreshing: snapshot.isRefreshing ?? false,
+        status: snapshot.status,
+        refresh,
+    };
+}
+function useRuntime(db) {
+    const contextRuntime = useContext(RuntimeContext);
+    if (db) {
+        if (contextRuntime && contextRuntime.client === db) {
+            return contextRuntime;
+        }
+        return getDefaultRuntime(db);
+    }
+    if (!contextRuntime) {
+        throw new Error("VennbaseProvider is missing.");
+    }
+    return contextRuntime;
+}
+function useResource(resource) {
+    const snapshot = useSyncExternalStore(resource ? resource.subscribe : noopSubscribe, resource ? resource.getSnapshot : () => getIdleSnapshot(), () => getIdleSnapshot());
+    return {
+        ...snapshot,
+        refresh: resource ? resource.refresh : noopRefresh,
+    };
+}
+function useOptionalResource(enabled, resourceKey, resourceOwner, resolve) {
+    const resource = useMemo(() => (enabled ? resolve() : null), [enabled, resourceKey, resourceOwner]);
+    return useResource(resource);
+}
+function useSessionResource(runtime, enabled) {
+    return useOptionalResource(enabled, "session", runtime, () => runtime.getLoadOnce("session", () => runtime.client.getSession(), snapshots.session));
+}
+function blockedResourceResult(session) {
+    if (session.status === "error") {
+        return makeResourceResult({
+            error: session.error,
+            status: "error",
+        }, session.refresh);
+    }
+    if (session.status !== "success" || !session.data?.signedIn) {
+        return makeResourceResult({
+            status: "idle",
+        }, session.refresh);
+    }
+    return null;
+}
+function getInviteInputFromUrl() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    const url = new URL(window.location.href);
+    if (url.searchParams.has(VENNBASE_INVITE_TARGET_PARAM)) {
+        return url.toString();
+    }
+    return null;
+}
+function clearInviteUrl(clearInviteParams, inviteInput) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    const current = new URL(window.location.href);
+    if (current.toString() !== inviteInput) {
+        return;
+    }
+    if (typeof clearInviteParams === "function") {
+        window.history.replaceState({}, "", clearInviteParams(current));
+        return;
+    }
+    current.search = "";
+    window.history.replaceState({}, "", `${current.pathname}${current.hash}`);
+}
+function hasRowRef(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return !!candidate.ref
+        && typeof candidate.ref === "object"
+        && typeof candidate.ref.id === "string"
+        && typeof candidate.ref.collection === "string"
+        && typeof candidate.ref.baseUrl === "string";
+}
+function resolveRowInput(row) {
+    return hasRowRef(row) ? row.ref : row;
+}
+function getRowFromResult(result, getRow) {
+    const row = getRow
+        ? getRow(result)
+        : hasRowRef(result)
+            ? result.ref
+            : null;
+    if (!row) {
+        throw new Error("useSavedRow could not resolve a row. Pass getRow when returning non-row data.");
+    }
+    return row;
+}
+export function VennbaseProvider({ children, db, subscribeToActivity, }) {
+    const runtimeRef = useRef(null);
+    if (runtimeRef.current === null ||
+        runtimeRef.current.client !== db ||
+        runtimeRef.current.externalSubscribeToActivity !== subscribeToActivity) {
+        runtimeRef.current = new Runtime(db, subscribeToActivity);
+    }
+    return (_jsx(RuntimeContext.Provider, { value: runtimeRef.current, children: children }));
+}
+export function useVennbase() {
+    return useRuntime().client;
+}
+export function useCrdt(row, adapter) {
+    const connectionRef = useRef(null);
+    const rowKeyRef = useRef(null);
+    const snapshotRef = useRef(null);
+    const getSnapshot = () => {
+        const nextValue = adapter.getValue();
+        const nextVersion = adapter.getVersion();
+        const cached = snapshotRef.current;
+        if (cached && cached.version === nextVersion && cached.value === nextValue) {
+            return cached;
+        }
+        const nextSnapshot = {
+            value: nextValue,
+            version: nextVersion,
+        };
+        snapshotRef.current = nextSnapshot;
+        return nextSnapshot;
+    };
+    const snapshot = useSyncExternalStore(adapter.subscribe, getSnapshot, getSnapshot);
+    useEffect(() => {
+        if (!row) {
+            if (rowKeyRef.current !== null) {
+                adapter.reset();
+                rowKeyRef.current = null;
+            }
+            connectionRef.current = null;
+            return;
+        }
+        const nextRowKey = `${row.ref.baseUrl}:${row.ref.id}`;
+        if (rowKeyRef.current !== null && rowKeyRef.current !== nextRowKey) {
+            adapter.reset();
+        }
+        const connection = row.connectCrdt(adapter.callbacks);
+        connectionRef.current = connection;
+        rowKeyRef.current = nextRowKey;
+        return () => {
+            connection.disconnect();
+            if (connectionRef.current === connection) {
+                connectionRef.current = null;
+            }
+        };
+    }, [adapter, row]);
+    return {
+        ...snapshot,
+        status: row ? "connected" : "idle",
+        async flush() {
+            if (!connectionRef.current) {
+                await noopFlush();
+                return;
+            }
+            await connectionRef.current.flush();
+        },
+    };
+}
+export function useVennbaseReady(db, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !blocked, "ready", runtime, () => runtime.getLoadOnce("ready", () => runtime.client.ensureReady()));
+    return blocked ?? resource;
+}
+export function useSession(db, options = {}) {
+    const runtime = useRuntime(db);
+    const resource = useSessionResource(runtime, options.enabled ?? true);
+    return {
+        ...resource,
+        session: resource.status === "success" ? resource.data : undefined,
+        async signIn() {
+            const user = await runtime.client.signIn();
+            await resource.refresh();
+            return user;
+        },
+    };
+}
+export function useCurrentUser(db, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    if (session.status === "error") {
+        return makeResourceResult({
+            error: session.error,
+            status: "error",
+        }, session.refresh);
+    }
+    if (session.status !== "success" || !session.data?.signedIn) {
+        return makeResourceResult({
+            status: "idle",
+        }, session.refresh);
+    }
+    return makeResourceResult({
+        data: session.data.user,
+        status: "success",
+    }, session.refresh);
+}
+export function useQuery(db, collection, options, hookOptions = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, hookOptions.enabled ?? true);
+    const resourceKey = options ? makeQueryKey(collection, options) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((hookOptions.enabled ?? true) && !!options && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.query(collection, options), snapshots.queryRows));
+    return {
+        ...(blocked ?? resource),
+        rows: (blocked ?? resource).data ?? [],
+    };
+}
+export function useRow(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeRowKey(rowRef.collection, rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.getRow(rowRef), snapshots.row));
+    return blocked ?? resource;
+}
+export function useParents(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeParentsKey(rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.listParents(rowRef), snapshots.rowRefs));
+    return blocked ?? resource;
+}
+export function useMemberUsernames(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeMembersKey("usernames", rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.listMembers(rowRef), snapshots.memberUsernames));
+    return blocked ?? resource;
+}
+export function useDirectMembers(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeMembersKey("direct", rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.listDirectMembers(rowRef), snapshots.directMembers));
+    return blocked ?? resource;
+}
+export function useEffectiveMembers(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeMembersKey("effective", rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLive(resourceKey, () => runtime.client.listEffectiveMembers(rowRef), snapshots.effectiveMembers));
+    return blocked ?? resource;
+}
+export function useShareLink(db, row, options = {}) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const rowRef = row ? resolveRowInput(row) : null;
+    const resourceKey = rowRef ? makeShareLinkKey(rowRef) : null;
+    const blocked = blockedResourceResult(session);
+    const resource = useOptionalResource((options.enabled ?? true) && !!rowRef && !blocked, resourceKey, runtime, () => runtime.getLoadOnce(resourceKey, async () => {
+        const existing = await runtime.client.getExistingInviteToken(rowRef);
+        const invite = existing ?? runtime.client.createInviteToken(rowRef).value;
+        return runtime.client.createShareLink(rowRef, invite.token);
+    }));
+    const result = blocked ?? resource;
+    return {
+        shareLink: result.data,
+        error: result.error,
+        refreshError: result.refreshError,
+        isRefreshing: result.isRefreshing,
+        status: result.status,
+        refresh: result.refresh,
+    };
+}
+export function useAcceptInviteFromUrl(db, options = {}) {
+    const runtime = useRuntime(db);
+    const enabled = options.enabled ?? true;
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const detectedInviteInput = options.url ?? getInviteInputFromUrl();
+    const [latchedInviteInput, setLatchedInviteInput] = useState(detectedInviteInput);
+    const inviteInput = enabled
+        ? detectedInviteInput ?? latchedInviteInput
+        : null;
+    const resourceKey = inviteInput ? makeIncomingInviteKey(inviteInput) : null;
+    const clearInviteParamsOption = options.clearInviteParams ?? true;
+    const deliveryKey = inviteInput ?? null;
+    const onOpenRef = useRef(options.onOpen);
+    const acceptRef = useRef(options.accept);
+    const clearInviteParamsRef = useRef(clearInviteParamsOption);
+    const [deliveryEpoch, setDeliveryEpoch] = useState(0);
+    const currentDeliveryKey = deliveryKey ? `${deliveryKey}:${deliveryEpoch}` : null;
+    const deliveryStateRef = useRef({
+        key: null,
+        status: "idle",
+        error: undefined,
+    });
+    const [deliveryState, setDeliveryState] = useState(deliveryStateRef.current);
+    onOpenRef.current = options.onOpen;
+    acceptRef.current = options.accept;
+    clearInviteParamsRef.current = clearInviteParamsOption;
+    useEffect(() => {
+        if (!enabled) {
+            if (latchedInviteInput !== null) {
+                setLatchedInviteInput(null);
+            }
+            return;
+        }
+        if (detectedInviteInput && detectedInviteInput !== latchedInviteInput) {
+            setLatchedInviteInput(detectedInviteInput);
+            return;
+        }
+        if (!detectedInviteInput
+            && latchedInviteInput !== null
+            && deliveryState.status === "success") {
+            setLatchedInviteInput(null);
+        }
+    }, [deliveryState.status, detectedInviteInput, enabled, latchedInviteInput]);
+    const resource = useOptionalResource((options.enabled ?? true)
+        && !!inviteInput
+        && session.status === "success"
+        && !!session.data?.signedIn, resourceKey, runtime, () => runtime.getLoadOnce(resourceKey, () => {
+        const acceptInvite = acceptRef.current;
+        if (acceptInvite) {
+            return acceptInvite(inviteInput, runtime.client);
+        }
+        return runtime.client.acceptInvite(inviteInput);
+    }));
+    useEffect(() => {
+        if (!currentDeliveryKey) {
+            const nextState = {
+                key: null,
+                status: "idle",
+                error: undefined,
+            };
+            if (deliveryStateRef.current.key !== nextState.key
+                || deliveryStateRef.current.status !== nextState.status
+                || deliveryStateRef.current.error !== nextState.error) {
+                deliveryStateRef.current = nextState;
+                setDeliveryState(nextState);
+            }
+            return;
+        }
+        if (resource.status !== "success" || resource.data === undefined) {
+            const nextState = {
+                key: currentDeliveryKey,
+                status: "idle",
+                error: undefined,
+            };
+            if (deliveryStateRef.current.key !== nextState.key
+                || deliveryStateRef.current.status !== nextState.status
+                || deliveryStateRef.current.error !== nextState.error) {
+                deliveryStateRef.current = nextState;
+                setDeliveryState(nextState);
+            }
+            return;
+        }
+        if (deliveryStateRef.current.key === currentDeliveryKey
+            && (deliveryStateRef.current.status === "loading"
+                || deliveryStateRef.current.status === "success"
+                || deliveryStateRef.current.status === "error")) {
+            return;
+        }
+        let cancelled = false;
+        const openedResult = resource.data;
+        const nextLoadingState = {
+            key: currentDeliveryKey,
+            status: "loading",
+            error: undefined,
+        };
+        deliveryStateRef.current = nextLoadingState;
+        setDeliveryState(nextLoadingState);
+        void (async () => {
+            try {
+                await onOpenRef.current?.(openedResult);
+                if (cancelled) {
+                    return;
+                }
+                const nextSuccessState = {
+                    key: currentDeliveryKey,
+                    status: "success",
+                    error: undefined,
+                };
+                deliveryStateRef.current = nextSuccessState;
+                setDeliveryState(nextSuccessState);
+                if (clearInviteParamsRef.current) {
+                    clearInviteUrl(clearInviteParamsRef.current, inviteInput);
+                }
+            }
+            catch (error) {
+                if (cancelled) {
+                    return;
+                }
+                const nextErrorState = {
+                    key: currentDeliveryKey,
+                    status: "error",
+                    error,
+                };
+                deliveryStateRef.current = nextErrorState;
+                setDeliveryState(nextErrorState);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [currentDeliveryKey, inviteInput, resource.data, resource.status]);
+    const refresh = async () => {
+        if (session.status !== "success" || !session.data?.signedIn) {
+            await session.refresh();
+            return;
+        }
+        await resource.refresh();
+        setDeliveryEpoch((epoch) => epoch + 1);
+    };
+    if (!enabled || !inviteInput) {
+        return {
+            hasInvite: false,
+            inviteInput: null,
+            ...makeResourceResult({
+                status: "idle",
+            }, noopRefresh),
+        };
+    }
+    if (session.status === "error") {
+        return {
+            hasInvite: true,
+            inviteInput,
+            ...makeResourceResult({
+                error: session.error,
+                status: "error",
+            }, refresh),
+        };
+    }
+    if (session.status !== "success") {
+        return {
+            hasInvite: true,
+            inviteInput,
+            ...makeResourceResult({
+                status: "loading",
+            }, refresh),
+        };
+    }
+    if (!session.data?.signedIn) {
+        return {
+            hasInvite: true,
+            inviteInput,
+            ...makeResourceResult({
+                status: "idle",
+            }, refresh),
+        };
+    }
+    if (resource.status !== "success" || resource.data === undefined) {
+        return {
+            ...resource,
+            hasInvite: true,
+            inviteInput,
+            refresh,
+        };
+    }
+    if (deliveryState.key !== currentDeliveryKey
+        || deliveryState.status === "idle"
+        || deliveryState.status === "loading") {
+        return {
+            hasInvite: true,
+            inviteInput,
+            ...makeResourceResult({
+                isRefreshing: resource.isRefreshing,
+                refreshError: resource.refreshError,
+                status: "loading",
+            }, refresh),
+        };
+    }
+    if (deliveryState.status === "error") {
+        return {
+            hasInvite: true,
+            inviteInput,
+            ...makeResourceResult({
+                error: deliveryState.error,
+                isRefreshing: resource.isRefreshing,
+                refreshError: resource.refreshError,
+                status: "error",
+            }, refresh),
+        };
+    }
+    return {
+        ...resource,
+        hasInvite: true,
+        inviteInput,
+        refresh,
+    };
+}
+export function useSavedRow(db, options) {
+    const runtime = useRuntime(db);
+    const session = useSessionResource(runtime, options.enabled ?? true);
+    const inviteInput = options.url ?? getInviteInputFromUrl();
+    const clearInviteParamsOption = options.clearInviteParams ?? true;
+    const sessionUser = session.status === "success" && session.data?.signedIn
+        ? session.data.user
+        : null;
+    const scopeKey = sessionUser ? `${sessionUser.username}:${options.key}` : null;
+    const resourceKey = sessionUser
+        ? makeSavedRowKey(sessionUser.username, options.key, inviteInput)
+        : null;
+    const [localData, setLocalData] = useState(null);
+    const clearedInviteRef = useRef(null);
+    const resource = useOptionalResource((options.enabled ?? true)
+        && !!resourceKey
+        && session.status === "success"
+        && !!session.data?.signedIn, resourceKey, runtime, () => runtime.getLoadOnce(resourceKey, async () => {
+        if (inviteInput) {
+            const opened = options.acceptInvite
+                ? await options.acceptInvite(inviteInput, runtime.client)
+                : await runtime.client.acceptInvite(inviteInput);
+            await runtime.client.saveRow(options.key, getRowFromResult(opened, options.getRow));
+            return opened;
+        }
+        try {
+            const savedRow = await runtime.client.openSavedRow(options.key);
+            if (!savedRow) {
+                return null;
+            }
+            return options.loadSavedRow
+                ? await options.loadSavedRow(savedRow, runtime.client)
+                : savedRow;
+        }
+        catch (error) {
+            await runtime.client.clearSavedRow(options.key);
+            throw error;
+        }
+    }));
+    useEffect(() => {
+        if (!inviteInput || resource.status !== "success") {
+            return;
+        }
+        if (clearInviteParamsOption && clearedInviteRef.current !== inviteInput) {
+            clearedInviteRef.current = inviteInput;
+            clearInviteUrl(clearInviteParamsOption, inviteInput);
+        }
+    }, [clearInviteParamsOption, inviteInput, resource.status]);
+    const localOverride = localData && localData.scopeKey === scopeKey
+        ? localData
+        : null;
+    const effective = localOverride
+        ? makeResourceResult({
+            data: localOverride.data,
+            status: "success",
+        })
+        : resource;
+    const refresh = async () => {
+        if (localOverride) {
+            setLocalData(null);
+        }
+        if (!(options.enabled ?? true)) {
+            return;
+        }
+        if (session.status !== "success" || !session.data?.signedIn) {
+            await session.refresh();
+            return;
+        }
+        await resource.refresh();
+    };
+    const save = async (result) => {
+        await runtime.client.saveRow(options.key, getRowFromResult(result, options.getRow));
+        if (scopeKey) {
+            setLocalData({ scopeKey, data: result });
+        }
+    };
+    const clear = async () => {
+        await runtime.client.clearSavedRow(options.key);
+        if (scopeKey) {
+            setLocalData({ scopeKey, data: null });
+            return;
+        }
+        setLocalData(null);
+    };
+    if (!(options.enabled ?? true)) {
+        return {
+            ...makeResourceResult({
+                status: "idle",
+            }, refresh),
+            clear,
+            hasInvite: !!inviteInput,
+            inviteInput,
+            save,
+            refresh,
+        };
+    }
+    if (session.status === "error") {
+        return {
+            ...makeResourceResult({
+                error: session.error,
+                status: "error",
+            }, refresh),
+            clear,
+            hasInvite: !!inviteInput,
+            inviteInput,
+            save,
+            refresh,
+        };
+    }
+    if (session.status !== "success") {
+        return {
+            ...makeResourceResult({
+                status: "loading",
+            }, refresh),
+            clear,
+            hasInvite: !!inviteInput,
+            inviteInput,
+            save,
+            refresh,
+        };
+    }
+    if (!session.data?.signedIn) {
+        return {
+            ...makeResourceResult({
+                status: "idle",
+            }, refresh),
+            clear,
+            hasInvite: !!inviteInput,
+            inviteInput,
+            save,
+            refresh,
+        };
+    }
+    return {
+        ...effective,
+        clear,
+        hasInvite: !!inviteInput,
+        inviteInput,
+        save,
+        refresh,
+    };
+}
+export function useMutation(mutation) {
+    const mutationRef = useRef(mutation);
+    mutationRef.current = mutation;
+    const [state, setState] = useState({
+        data: undefined,
+        error: undefined,
+        status: "idle",
+    });
+    return {
+        ...state,
+        async mutate(...args) {
+            setState((current) => ({
+                data: current.data,
+                error: undefined,
+                status: "loading",
+            }));
+            try {
+                const result = await mutationRef.current(...args);
+                setState({
+                    data: result,
+                    error: undefined,
+                    status: "success",
+                });
+                return result;
+            }
+            catch (error) {
+                setState((current) => ({
+                    data: current.data,
+                    error,
+                    status: "error",
+                }));
+                throw error;
+            }
+        },
+        reset() {
+            setState({
+                data: undefined,
+                error: undefined,
+                status: "idle",
+            });
+        },
+    };
+}
+//# sourceMappingURL=index.js.map