@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/react-common/dist/esm/InstantReactRoom.js

@@ -0,0 +1,280 @@
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { useTimeout } from './useTimeout.js';
+export const defaultActivityStopTimeout = 1_000;
+// ------
+// Topics
+/**
+ * Listen for broadcasted events given a room and topic.
+ *
+ * @see https://instantdb.com/docs/presence-and-topics
+ * @example
+ *  function App({ roomId }) {
+ *    const room = db.room('chats', roomId);
+ *    db.rooms.useTopicEffect(room, 'emoji', (message, peer) => {
+ *      console.log(peer.name, 'sent', message);
+ *    });
+ *    // ...
+ *  }
+ */
+export function useTopicEffect(room, topic, onEvent) {
+    const onEventRef = useRef(onEvent);
+    onEventRef.current = onEvent;
+    useEffect(() => {
+        const unsub = room.core._reactor.subscribeTopic(room.type, room.id, topic, (event, peer) => {
+            onEventRef.current(event, peer);
+        });
+        return unsub;
+    }, [room.id, topic]);
+}
+/**
+ * Broadcast an event to a room.
+ *
+ * @see https://instantdb.com/docs/presence-and-topics
+ * @example
+ * function App({ roomId }) {
+ *   const room = db.room('chat', roomId);
+ *   const publishTopic = db.rooms.usePublishTopic(room, "emoji");
+ *
+ *   return (
+ *     <button onClick={() => publishTopic({ emoji: "🔥" })}>Send emoji</button>
+ *   );
+ * }
+ *
+ */
+export function usePublishTopic(room, topic) {
+    useEffect(() => room.core._reactor.joinRoom(room.type, room.id), [room.id]);
+    const publishTopic = useCallback((data) => {
+        room.core._reactor.publishTopic({
+            roomType: room.type,
+            roomId: room.id,
+            topic,
+            data,
+        });
+    }, [room.id, topic]);
+    return publishTopic;
+}
+// ---------
+// Presence
+/**
+ * Listen for peer's presence data in a room, and publish the current user's presence.
+ *
+ * @see https://instantdb.com/docs/presence-and-topics
+ * @example
+ *  function App({ roomId }) {
+ *    const {
+ *      peers,
+ *      publishPresence
+ *    } = db.room(roomType, roomId).usePresence({ keys: ["name", "avatar"] });
+ *
+ *    // ...
+ *  }
+ */
+export function usePresence(room, opts = {}) {
+    const [state, setState] = useState(() => {
+        return (room.core._reactor.getPresence(room.type, room.id, opts) ?? {
+            peers: {},
+            isLoading: true,
+        });
+    });
+    useEffect(() => {
+        const unsub = room.core._reactor.subscribePresence(room.type, room.id, opts, (data) => {
+            setState(data);
+        });
+        return unsub;
+    }, [room.id, opts.user, opts.peers?.join(), opts.keys?.join()]);
+    const publishPresence = useCallback((data) => {
+        room.core._reactor.publishPresence(room.type, room.id, data);
+    }, [room.type, room.id]);
+    const ret = useMemo(() => {
+        return {
+            ...state,
+            publishPresence,
+        };
+    }, [state, publishPresence]);
+    return ret;
+}
+/**
+ * Publishes presence data to a room
+ *
+ * @see https://instantdb.com/docs/presence-and-topics
+ * @example
+ *  function App({ roomId, nickname }) {
+ *    const room = db.room('chat', roomId);
+ *    db.rooms.useSyncPresence(room, { nickname });
+ *  }
+ */
+export function useSyncPresence(room, data, deps) {
+    useEffect(() => room.core._reactor.joinRoom(room.type, room.id, data), [room.id]);
+    useEffect(() => {
+        return room.core._reactor.publishPresence(room.type, room.id, data);
+    }, [room.type, room.id, deps ?? JSON.stringify(data)]);
+}
+// -----------------
+// Typing Indicator
+/**
+ * Manage typing indicator state
+ *
+ * @see https://instantdb.com/docs/presence-and-topics
+ * @example
+ *  function App({ roomId }) {
+ *    const room = db.room('chat', roomId);
+ *    const {
+ *      active,
+ *      setActive,
+ *      inputProps,
+ *    } = db.rooms.useTypingIndicator(room, "chat-input");
+ *
+ *    return <input {...inputProps} />;
+ *  }
+ */
+export function useTypingIndicator(room, inputName, opts = {}) {
+    const timeout = useTimeout();
+    const observedPresence = rooms.usePresence(room, {
+        keys: [inputName],
+    });
+    const active = useMemo(() => {
+        const presenceSnapshot = room._core._reactor.getPresence(room.type, room.id);
+        return opts?.writeOnly
+            ? []
+            : Object.values(presenceSnapshot?.peers ?? {}).filter((p) => p[inputName] === true);
+    }, [opts?.writeOnly, observedPresence]);
+    const setActive = useCallback((isActive) => {
+        room.core._reactor.publishPresence(room.type, room.id, {
+            [inputName]: isActive,
+        });
+        if (!isActive)
+            return;
+        if (opts?.timeout === null || opts?.timeout === 0)
+            return;
+        timeout.set(opts?.timeout ?? defaultActivityStopTimeout, () => {
+            room.core._reactor.publishPresence(room.type, room.id, {
+                [inputName]: null,
+            });
+        });
+    }, [room.type, room.id, inputName, opts?.timeout, timeout]);
+    const onKeyDown = useCallback((e) => {
+        const isEnter = opts?.stopOnEnter && e.key === 'Enter';
+        const isActive = !isEnter;
+        setActive(isActive);
+    }, [opts.stopOnEnter, setActive]);
+    const onBlur = useCallback(() => {
+        setActive(false);
+    }, [setActive]);
+    const inputProps = useMemo(() => {
+        return { onKeyDown, onBlur };
+    }, [onKeyDown, onBlur]);
+    return {
+        active,
+        setActive,
+        inputProps,
+    };
+}
+// --------------
+// Hooks
+export const rooms = {
+    useTopicEffect,
+    usePublishTopic,
+    usePresence,
+    useSyncPresence,
+    useTypingIndicator,
+};
+// ------------
+// Class
+export class InstantReactRoom {
+    core;
+    /** @deprecated use `core` instead */
+    _core;
+    type;
+    id;
+    constructor(core, type, id) {
+        this.core = core;
+        this._core = this.core;
+        this.type = type;
+        this.id = id;
+    }
+    /**
+     * @deprecated
+     * `db.room(...).useTopicEffect` is deprecated. You can replace it with `db.rooms.useTopicEffect`.
+     *
+     * @example
+     *
+     * // Before
+     * const room = db.room('chat', 'room-id');
+     * room.useTopicEffect('emoji', (message, peer) => {  });
+     *
+     * // After
+     * const room = db.room('chat', 'room-id');
+     * db.rooms.useTopicEffect(room, 'emoji', (message, peer) => {  });
+     */
+    useTopicEffect = (topic, onEvent) => {
+        rooms.useTopicEffect(this, topic, onEvent);
+    };
+    /**
+     * @deprecated
+     * `db.room(...).usePublishTopic` is deprecated. You can replace it with `db.rooms.usePublishTopic`.
+     *
+     * @example
+     *
+     * // Before
+     * const room = db.room('chat', 'room-id');
+     * const publish = room.usePublishTopic('emoji');
+     *
+     * // After
+     * const room = db.room('chat', 'room-id');
+     * const publish = db.rooms.usePublishTopic(room, 'emoji');
+     */
+    usePublishTopic = (topic) => {
+        return rooms.usePublishTopic(this, topic);
+    };
+    /**
+     * @deprecated
+     * `db.room(...).usePresence` is deprecated. You can replace it with `db.rooms.usePresence`.
+     *
+     * @example
+     *
+     * // Before
+     * const room = db.room('chat', 'room-id');
+     * const { peers } = room.usePresence({ keys: ["name", "avatar"] });
+     *
+     * // After
+     * const room = db.room('chat', 'room-id');
+     * const { peers } = db.rooms.usePresence(room, { keys: ["name", "avatar"] });
+     */
+    usePresence = (opts = {}) => {
+        return rooms.usePresence(this, opts);
+    };
+    /**
+     * @deprecated
+     * `db.room(...).useSyncPresence` is deprecated. You can replace it with `db.rooms.useSyncPresence`.
+     *
+     * @example
+     *
+     * // Before
+     * const room = db.room('chat', 'room-id');
+     * room.useSyncPresence(room, { nickname });
+     *
+     * // After
+     * const room = db.room('chat', 'room-id');
+     * db.rooms.useSyncPresence(room, { nickname });
+     */
+    useSyncPresence = (data, deps) => {
+        return rooms.useSyncPresence(this, data, deps);
+    };
+    /**
+     * @deprecated
+     * `db.room(...).useTypingIndicator` is deprecated. You can replace it with `db.rooms.useTypingIndicator`.
+     *
+     * @example
+     *
+     * // Before
+     * const room = db.room('chat', 'room-id');
+     * const typing = room.useTypingIndiactor(room, 'chat-input');
+     *
+     * // After
+     * const room = db.room('chat', 'room-id');
+     * const typing = db.rooms.useTypingIndiactor(room, 'chat-input');
+     */
+    useTypingIndicator = (inputName, opts = {}) => {
+        return rooms.useTypingIndicator(this, inputName, opts);
+    };
+}

package/node_modules/@instantdb/react-common/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import InstantReactAbstractDatabase from './InstantReactAbstractDatabase.tsx';
+import type { InstantReactRoom } from './InstantReactRoom.ts';
+import { useQueryInternal } from './useQuery.ts';
+export { InstantReactAbstractDatabase, type InstantReactRoom, useQueryInternal, };

package/node_modules/@instantdb/react-common/dist/esm/index.js

@@ -0,0 +1,3 @@
+import InstantReactAbstractDatabase from './InstantReactAbstractDatabase.js';
+import { useQueryInternal } from './useQuery.js';
+export { InstantReactAbstractDatabase, useQueryInternal, };

package/node_modules/@instantdb/react-common/dist/esm/useInfiniteQuerySubscription.d.ts

@@ -0,0 +1,27 @@
+import { type InstantCoreDatabase, type InstantSchemaDef, type InstaQLOptions, InstaQLResponse, ValidQuery } from '@instantdb/core';
+export type InfiniteQueryResult<Schema extends InstantSchemaDef<any, any, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> = {
+    error: {
+        message: string;
+    };
+    data: undefined;
+    isLoading: false;
+    canLoadNextPage: boolean;
+    loadNextPage: () => void;
+} | {
+    error: undefined;
+    data: undefined;
+    isLoading: true;
+    canLoadNextPage: boolean;
+    loadNextPage: () => void;
+} | {
+    error: undefined;
+    data: InstaQLResponse<Schema, Q, UseDates>;
+    isLoading: false;
+    canLoadNextPage: boolean;
+    loadNextPage: () => void;
+};
+export declare function useInfiniteQuerySubscription<Schema extends InstantSchemaDef<any, any, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean>({ core, query, opts, }: {
+    core: InstantCoreDatabase<Schema, UseDates>;
+    query: Q | null;
+    opts?: InstaQLOptions;
+}): InfiniteQueryResult<Schema, Q, UseDates>;

package/node_modules/@instantdb/react-common/dist/esm/useInfiniteQuerySubscription.js

@@ -0,0 +1,53 @@
+import { weakHash, getInfiniteQueryInitialSnapshot, } from '@instantdb/core';
+import { useCallback, useRef, useSyncExternalStore } from 'react';
+const defaultState = {
+    error: undefined,
+    data: undefined,
+    isLoading: true,
+    canLoadNextPage: false,
+};
+export function useInfiniteQuerySubscription({ core, query, opts, }) {
+    const subRef = useRef(null);
+    const queryHash = weakHash(query);
+    const optsHash = weakHash(opts);
+    const snapshot = getInfiniteQueryInitialSnapshot(core, query, opts);
+    const stateCacheRef = useRef({
+        ...snapshot,
+        isLoading: !snapshot.data && !snapshot.error,
+    });
+    const subscribe = useCallback((cb) => {
+        subRef.current = null;
+        const nextSnapshot = getInfiniteQueryInitialSnapshot(core, query, opts);
+        stateCacheRef.current = {
+            ...nextSnapshot,
+            isLoading: !nextSnapshot.data && !nextSnapshot.error,
+        };
+        cb();
+        if (!query) {
+            return () => { };
+        }
+        const sub = core.subscribeInfiniteQuery(query, (resp) => {
+            stateCacheRef.current = {
+                ...resp,
+                isLoading: false,
+            };
+            cb();
+        }, opts);
+        subRef.current = sub;
+        return () => {
+            sub.unsubscribe();
+            if (subRef.current === sub) {
+                subRef.current = null;
+            }
+        };
+    }, [queryHash, optsHash]);
+    const state = useSyncExternalStore(subscribe, () => stateCacheRef.current, () => defaultState);
+    const loadNextPage = () => {
+        subRef.current?.loadNextPage();
+    };
+    // @ts-expect-error union type
+    return {
+        ...state,
+        loadNextPage,
+    };
+}

package/node_modules/@instantdb/react-common/dist/esm/useQuery.d.ts

@@ -0,0 +1,6 @@
+import { type InstaQLOptions, InstantCoreDatabase, InstaQLLifecycleState, InstantSchemaDef, ValidQuery } from '@instantdb/core';
+export declare function useQueryInternal<Q extends ValidQuery<Q, Schema>, Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean>(_core: InstantCoreDatabase<Schema, UseDates>, _query: null | Q, _opts?: InstaQLOptions, serverSnapshot?: () => InstaQLLifecycleState<Schema, Q, UseDates> | undefined): {
+    state: InstaQLLifecycleState<Schema, Q, UseDates>;
+    query: any;
+    queryHash: string;
+};

package/node_modules/@instantdb/react-common/dist/esm/useQuery.js

@@ -0,0 +1,75 @@
+'use client';
+import { weakHash, coerceQuery, } from '@instantdb/core';
+import { useCallback, useRef, useSyncExternalStore } from 'react';
+const defaultState = {
+    isLoading: true,
+    data: undefined,
+    pageInfo: undefined,
+    error: undefined,
+};
+function stateForResult(result) {
+    return {
+        isLoading: !Boolean(result),
+        data: undefined,
+        pageInfo: undefined,
+        error: undefined,
+        ...(result ? result : {}),
+    };
+}
+export function useQueryInternal(_core, _query, _opts, serverSnapshot) {
+    if (_query && _opts && 'ruleParams' in _opts) {
+        _query = { $$ruleParams: _opts['ruleParams'], ..._query };
+    }
+    const query = _query ? coerceQuery(_query) : null;
+    const queryHash = weakHash(query);
+    // We use a ref to store the result of the query.
+    // This is becuase `useSyncExternalStore` uses `Object.is`
+    // to compare the previous and next state.
+    // If we don't use a ref, the state will always be considered different, so
+    // the component will always re-render.
+    const resultCacheRef = useRef(stateForResult(_core._reactor.getPreviousResult(query)));
+    // Cache the server snapshot to satisfy useSyncExternalStore's requirement
+    // that getServerSnapshot returns the same reference across calls.
+    const serverSnapshotCacheRef = useRef(defaultState);
+    // Similar to `resultCacheRef`, `useSyncExternalStore` will unsubscribe
+    // if `subscribe` changes, so we use `useCallback` to memoize the function.
+    const subscribe = useCallback((cb) => {
+        // Update the ref when the query changes to avoid showing stale data
+        resultCacheRef.current = stateForResult(_core._reactor.getPreviousResult(query));
+        // before the subscribeQuery is connected and calls it's own callback,
+        // we might have data in the store via SSR, we need to notify useSyncExternalStore that
+        // the data has changed.
+        cb();
+        // Don't subscribe if query is null
+        if (!query) {
+            const unsubscribe = () => { };
+            return unsubscribe;
+        }
+        const unsubscribe = _core.subscribeQuery(query, (result) => {
+            resultCacheRef.current = {
+                isLoading: !Boolean(result),
+                // @ts-expect-error: ts thinks this will always be overwritten
+                data: undefined,
+                // @ts-expect-error: ts thinks this will always be overwritten
+                pageInfo: undefined,
+                // @ts-expect-error: ts thinks this will always be overwritten
+                error: undefined,
+                ...result,
+            };
+            cb();
+        });
+        return unsubscribe;
+    }, 
+    // Build a new subscribe function if the query changes
+    [queryHash]);
+    const state = useSyncExternalStore(subscribe, () => resultCacheRef.current, () => {
+        if (serverSnapshot && serverSnapshotCacheRef.current === defaultState) {
+            const result = serverSnapshot();
+            if (result) {
+                serverSnapshotCacheRef.current = result;
+            }
+        }
+        return serverSnapshotCacheRef.current;
+    });
+    return { state, query, queryHash };
+}

package/node_modules/@instantdb/react-common/dist/esm/useTimeout.d.ts

@@ -0,0 +1,4 @@
+export declare function useTimeout(): {
+    set: (delay: number, fn: () => void) => void;
+    clear: () => void;
+};

package/node_modules/@instantdb/react-common/dist/esm/useTimeout.js

@@ -0,0 +1,17 @@
+import { useEffect, useRef } from 'react';
+export function useTimeout() {
+    const timeoutRef = useRef(null);
+    useEffect(() => {
+        clear();
+    }, []);
+    function set(delay, fn) {
+        clear();
+        timeoutRef.current = setTimeout(fn, delay);
+    }
+    function clear() {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+    }
+    return { set, clear };
+}

package/node_modules/@instantdb/react-common/dist/esm/version.d.ts

@@ -0,0 +1,2 @@
+import { version } from '@instantdb/version';
+export default version;

package/node_modules/@instantdb/react-common/dist/esm/version.js

@@ -0,0 +1,2 @@
+import { version } from '@instantdb/version';
+export default version;

package/node_modules/@instantdb/react-common/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@instantdb/react-common",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "license": "Apache-2.0",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@instantdb/core": "0.0.0",
+    "@instantdb/version": "0.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=16"
+  }
+}