@instantdb/react-common 0.22.15-experimental.react-common.18536829600.1

package/dist/commonjs/useQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.js","sourceRoot":"","sources":["../../src/useQuery.ts"],"names":[],"mappings":";;AA8BA,4CAoEC;AAlGD,0CAUyB;AACzB,iCAAkE;AAElE,MAAM,YAAY,GAAG;IACnB,SAAS,EAAE,IAAI;IACf,IAAI,EAAE,SAAS;IACf,QAAQ,EAAE,SAAS;IACnB,KAAK,EAAE,SAAS;CACjB,CAAC;AAEF,SAAS,cAAc,CAAC,MAAW;IACjC,uBACE,SAAS,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAC3B,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,SAAS,IACb,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EACzB;AACJ,CAAC;AAED,SAAgB,gBAAgB,CAK9B,KAA4C,EAC5C,MAAgB,EAChB,KAAsB;IAKtB,IAAI,MAAM,IAAI,KAAK,IAAI,YAAY,IAAI,KAAK,EAAE,CAAC;QAC7C,MAAM,mBAAK,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,IAAK,MAAM,CAAE,CAAC;IAC5D,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,IAAA,kBAAW,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAClD,MAAM,SAAS,GAAG,IAAA,eAAQ,EAAC,KAAK,CAAC,CAAC;IAElC,iDAAiD;IACjD,0DAA0D;IAC1D,0CAA0C;IAC1C,2EAA2E;IAC3E,uCAAuC;IACvC,MAAM,cAAc,GAAG,IAAA,cAAM,EAC3B,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CACxD,CAAC;IAEF,uEAAuE;IACvE,2EAA2E;IAC3E,MAAM,SAAS,GAAG,IAAA,mBAAW,EAC3B,CAAC,EAAE,EAAE,EAAE;QACL,oEAAoE;QACpE,cAAc,CAAC,OAAO,GAAG,cAAc,CACrC,KAAK,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CACxC,CAAC;QAEF,mCAAmC;QACnC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,WAAW,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;YAC7B,OAAO,WAAW,CAAC;QACrB,CAAC;QAED,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,CAAc,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE;YACtE,cAAc,CAAC,OAAO,mBACpB,SAAS,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAC3B,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,SAAS,IACb,MAAM,CACV,CAAC;YAEF,EAAE,EAAE,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,sDAAsD;IACtD,CAAC,SAAS,CAAC,CACZ,CAAC;IAEF,MAAM,KAAK,GAAG,IAAA,4BAAoB,EAGhC,SAAS,EACT,GAAG,EAAE,CAAC,cAAc,CAAC,OAAO,EAC5B,GAAG,EAAE,CAAC,YAAY,CACnB,CAAC;IACF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC1B,CAAC","sourcesContent":["import {\n  weakHash,\n  coerceQuery,\n  type InstaQLParams,\n  type InstaQLOptions,\n  type InstantGraph,\n  InstantCoreDatabase,\n  InstaQLLifecycleState,\n  InstantSchemaDef,\n  ValidQuery,\n} from '@instantdb/core';\nimport { useCallback, useRef, useSyncExternalStore } from 'react';\n\nconst defaultState = {\n  isLoading: true,\n  data: undefined,\n  pageInfo: undefined,\n  error: undefined,\n};\n\nfunction stateForResult(result: any) {\n  return {\n    isLoading: !Boolean(result),\n    data: undefined,\n    pageInfo: undefined,\n    error: undefined,\n    ...(result ? result : {}),\n  };\n}\n\nexport function useQueryInternal<\n  Q extends ValidQuery<Q, Schema>,\n  Schema extends InstantSchemaDef<any, any, any>,\n  UseDates extends boolean,\n>(\n  _core: InstantCoreDatabase<Schema, UseDates>,\n  _query: null | Q,\n  _opts?: InstaQLOptions,\n): {\n  state: InstaQLLifecycleState<Schema, Q, UseDates>;\n  query: any;\n} {\n  if (_query && _opts && 'ruleParams' in _opts) {\n    _query = { $$ruleParams: _opts['ruleParams'], ..._query };\n  }\n  const query = _query ? coerceQuery(_query) : null;\n  const queryHash = weakHash(query);\n\n  // We use a ref to store the result of the query.\n  // This is becuase `useSyncExternalStore` uses `Object.is`\n  // to compare the previous and next state.\n  // If we don't use a ref, the state will always be considered different, so\n  // the component will always re-render.\n  const resultCacheRef = useRef<InstaQLLifecycleState<Schema, Q, UseDates>>(\n    stateForResult(_core._reactor.getPreviousResult(query)),\n  );\n\n  // Similar to `resultCacheRef`, `useSyncExternalStore` will unsubscribe\n  // if `subscribe` changes, so we use `useCallback` to memoize the function.\n  const subscribe = useCallback(\n    (cb) => {\n      // Update the ref when the query changes to avoid showing stale data\n      resultCacheRef.current = stateForResult(\n        _core._reactor.getPreviousResult(query),\n      );\n\n      // Don't subscribe if query is null\n      if (!query) {\n        const unsubscribe = () => {};\n        return unsubscribe;\n      }\n\n      const unsubscribe = _core.subscribeQuery<Q, UseDates>(query, (result) => {\n        resultCacheRef.current = {\n          isLoading: !Boolean(result),\n          data: undefined,\n          pageInfo: undefined,\n          error: undefined,\n          ...result,\n        };\n\n        cb();\n      });\n\n      return unsubscribe;\n    },\n    // Build a new subscribe function if the query changes\n    [queryHash],\n  );\n\n  const state = useSyncExternalStore<\n    InstaQLLifecycleState<Schema, Q, UseDates>\n  >(\n    subscribe,\n    () => resultCacheRef.current,\n    () => defaultState,\n  );\n  return { state, query };\n}\n"]}

package/dist/commonjs/useTimeout.d.ts

@@ -0,0 +1,5 @@
+export declare function useTimeout(): {
+    set: (delay: number, fn: () => void) => void;
+    clear: () => void;
+};
+//# sourceMappingURL=useTimeout.d.ts.map

package/dist/commonjs/useTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeout.d.ts","sourceRoot":"","sources":["../../src/useTimeout.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU;iBAOJ,MAAM,MAAM,MAAM,IAAI;;EAU3C"}

package/dist/commonjs/useTimeout.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTimeout = useTimeout;
+const react_1 = require("react");
+function useTimeout() {
+    const timeoutRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        clear();
+    }, []);
+    function set(delay, fn) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(fn, delay);
+    }
+    function clear() {
+        clearTimeout(timeoutRef.current);
+    }
+    return { set, clear };
+}
+//# sourceMappingURL=useTimeout.js.map

package/dist/commonjs/useTimeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeout.js","sourceRoot":"","sources":["../../src/useTimeout.ts"],"names":[],"mappings":";;AAEA,gCAiBC;AAnBD,iCAA0C;AAE1C,SAAgB,UAAU;IACxB,MAAM,UAAU,GAAG,IAAA,cAAM,EAAC,IAAI,CAAC,CAAC;IAEhC,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,KAAK,EAAE,CAAC;IACV,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,SAAS,GAAG,CAAC,KAAa,EAAE,EAAc;QACxC,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACjC,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,SAAS,KAAK;QACZ,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;AACxB,CAAC","sourcesContent":["import { useEffect, useRef } from 'react';\n\nexport function useTimeout() {\n  const timeoutRef = useRef(null);\n\n  useEffect(() => {\n    clear();\n  }, []);\n\n  function set(delay: number, fn: () => void) {\n    clearTimeout(timeoutRef.current);\n    timeoutRef.current = setTimeout(fn, delay);\n  }\n\n  function clear() {\n    clearTimeout(timeoutRef.current);\n  }\n\n  return { set, clear };\n}\n"]}

package/dist/commonjs/version.d.ts

@@ -0,0 +1,3 @@
+import { version } from '@instantdb/version';
+export default version;
+//# sourceMappingURL=version.d.ts.map

package/dist/commonjs/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,eAAe,OAAO,CAAC"}

package/dist/commonjs/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const version_1 = require("@instantdb/version");
+exports.default = version_1.version;
+//# sourceMappingURL=version.js.map

package/dist/commonjs/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;AAAA,gDAA6C;AAE7C,kBAAe,iBAAO,CAAC","sourcesContent":["import { version } from '@instantdb/version';\n\nexport default version;\n"]}

package/dist/esm/InstantReactAbstractDatabase.d.ts

@@ -0,0 +1,241 @@
+import { Auth, Storage, type AuthState, type User, type ConnectionStatus, type TransactionChunk, type RoomSchemaShape, type InstaQLOptions, type InstantConfig, type PageInfoResponse, InstantCoreDatabase, InstaQLLifecycleState, InstaQLResponse, RoomsOf, InstantSchemaDef, IInstantDatabase, ValidQuery } from '@instantdb/core';
+import { ReactNode } from 'react';
+import { InstantReactRoom } from './InstantReactRoom.ts';
+export default abstract class InstantReactAbstractDatabase<Schema extends InstantSchemaDef<any, any, any>, Config extends InstantConfig<Schema, boolean> = InstantConfig<Schema, false>, Rooms extends RoomSchemaShape = RoomsOf<Schema>> implements IInstantDatabase<Schema> {
+    tx: import("@instantdb/core").TxChunk<Schema>;
+    auth: Auth;
+    storage: Storage;
+    core: InstantCoreDatabase<Schema, Config['useDateObjects']>;
+    /** @deprecated use `core` instead */
+    _core: InstantCoreDatabase<Schema, Config['useDateObjects']>;
+    static Storage?: any;
+    static NetworkListener?: any;
+    static EventSourceImpl?: any;
+    constructor(config: Config, versions?: {
+        [key: string]: string;
+    });
+    /**
+     * Returns a unique ID for a given `name`. It's stored in local storage,
+     * so you will get the same ID across sessions.
+     *
+     * This is useful for generating IDs that could identify a local device or user.
+     *
+     * @example
+     *  const deviceId = await db.getLocalId('device');
+     */
+    getLocalId: (name: string) => Promise<string>;
+    /**
+     * A hook that returns a unique ID for a given `name`. localIds are
+     * stored in local storage, so you will get the same ID across sessions.
+     *
+     * Initially returns `null`, and then loads the localId.
+     *
+     * @example
+     * const deviceId = db.useLocalId('device');
+     * if (!deviceId) return null; // loading
+     * console.log('Device ID:', deviceId)
+     */
+    useLocalId: (name: string) => string | null;
+    /**
+     * Obtain a handle to a room, which allows you to listen to topics and presence data
+     *
+     * If you don't provide a `type` or `id`, Instant will default to `_defaultRoomType` and `_defaultRoomId`
+     * as the room type and id, respectively.
+     *
+     * @see https://instantdb.com/docs/presence-and-topics
+     *
+     * @example
+     *  const room = db.room('chat', roomId);
+     *  const { peers } = db.rooms.usePresence(room);
+     */
+    room<RoomType extends keyof Rooms>(type?: RoomType, id?: string): InstantReactRoom<Schema, Rooms, RoomType>;
+    /**
+     * Hooks for working with rooms
+     *
+     * @see https://instantdb.com/docs/presence-and-topics
+     *
+     * @example
+     *  const room = db.room('chat', roomId);
+     *  const { peers } = db.rooms.usePresence(room);
+     *  const publish = db.rooms.usePublishTopic(room, 'emoji');
+     *  // ...
+     */
+    rooms: {
+        useTopicEffect: typeof import("./InstantReactRoom.ts").useTopicEffect;
+        usePublishTopic: typeof import("./InstantReactRoom.ts").usePublishTopic;
+        usePresence: typeof import("./InstantReactRoom.ts").usePresence;
+        useSyncPresence: typeof import("./InstantReactRoom.ts").useSyncPresence;
+        useTypingIndicator: typeof import("./InstantReactRoom.ts").useTypingIndicator;
+    };
+    /**
+     * Use this to write data! You can create, update, delete, and link objects
+     *
+     * @see https://instantdb.com/docs/instaml
+     *
+     * @example
+     *   // Create a new object in the `goals` namespace
+     *   const goalId = id();
+     *   db.transact(db.tx.goals[goalId].update({title: "Get fit"}))
+     *
+     *   // Update the title
+     *   db.transact(db.tx.goals[goalId].update({title: "Get super fit"}))
+     *
+     *   // Delete it
+     *   db.transact(db.tx.goals[goalId].delete())
+     *
+     *   // Or create an association:
+     *   todoId = id();
+     *   db.transact([
+     *    db.tx.todos[todoId].update({ title: 'Go on a run' }),
+     *    db.tx.goals[goalId].link({todos: todoId}),
+     *  ])
+     */
+    transact: (chunks: TransactionChunk<any, any> | TransactionChunk<any, any>[]) => Promise<import("@instantdb/core").TransactionResult>;
+    /**
+     * Use this to query your data!
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *   // listen to all goals
+     *   const { isLoading, error, data } = db.useQuery({ goals: {} });
+     *
+     *   // goals where the title is "Get Fit"
+     *   const { isLoading, error, data } = db.useQuery({
+     *     goals: { $: { where: { title: 'Get Fit' } } },
+     *   });
+     *
+     *   // all goals, _alongside_ their todos
+     *   const { isLoading, error, data } = db.useQuery({
+     *     goals: { todos: {} },
+     *   });
+     *
+     *   // skip if `user` is not logged in
+     *   const { isLoading, error, data } = db.useQuery(
+     *     auth.user ? { goals: {} } : null,
+     *   );
+     */
+    useQuery: <Q extends ValidQuery<Q, Schema>>(query: null | Q, opts?: InstaQLOptions) => InstaQLLifecycleState<Schema, Q, NonNullable<Config["useDateObjects"]>>;
+    /**
+     * Listen for the logged in state. This is useful
+     * for deciding when to show a login screen.
+     *
+     * Check out the docs for an example `Login` component too!
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *  function App() {
+     *    const { isLoading, user, error } = db.useAuth()
+     *    if (isLoading) {
+     *      return <div>Loading...</div>
+     *    }
+     *    if (error) {
+     *      return <div>Uh oh! {error.message}</div>
+     *    }
+     *    if (user) {
+     *      return <Main user={user} />
+     *    }
+     *    return <Login />
+     *  }
+     *
+     */
+    useAuth: () => AuthState;
+    /**
+     * Subscribe to the currently logged in user.
+     * If the user is not logged in, this hook with throw an Error.
+     * You will want to protect any calls of this hook with a
+     * <db.SignedIn> component, or your own logic based on db.useAuth()
+     *
+     * @see https://instantdb.com/docs/auth
+     * @throws Error indicating user not signed in
+     * @example
+     *  function UserDisplay() {
+     *    const user = db.useUser()
+     *    return <div>Logged in as: {user.email}</div>
+     *  }
+     *
+     *  <db.SignedIn>
+     *    <UserDisplay />
+     *  </db.SignedIn>
+     *
+     */
+    useUser: () => User;
+    /**
+     * One time query for the logged in state. This is useful
+     * for scenarios where you want to know the current auth
+     * state without subscribing to changes.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   const user = await db.getAuth();
+     *   console.log('logged in as', user.email)
+     */
+    getAuth(): Promise<User | null>;
+    /**
+     * Listen for connection status changes to Instant. Use this for things like
+     * showing connection state to users
+     *
+     * @see https://www.instantdb.com/docs/patterns#connection-status
+     * @example
+     *  function App() {
+     *    const status = db.useConnectionStatus()
+     *    const connectionState =
+     *      status === 'connecting' || status === 'opened'
+     *        ? 'authenticating'
+     *      : status === 'authenticated'
+     *        ? 'connected'
+     *      : status === 'closed'
+     *        ? 'closed'
+     *      : status === 'errored'
+     *        ? 'errored'
+     *      : 'unexpected state';
+     *
+     *    return <div>Connection state: {connectionState}</div>
+     *  }
+     */
+    useConnectionStatus: () => ConnectionStatus;
+    /**
+     * Use this for one-off queries.
+     * Returns local data if available, otherwise fetches from the server.
+     * Because we want to avoid stale data, this method will throw an error
+     * if the user is offline or there is no active connection to the server.
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *
+     *  const resp = await db.queryOnce({ goals: {} });
+     *  console.log(resp.data.goals)
+     */
+    queryOnce: <Q extends ValidQuery<Q, Schema>>(query: Q, opts?: InstaQLOptions) => Promise<{
+        data: InstaQLResponse<Schema, Q, Config["useDateObjects"]>;
+        pageInfo: PageInfoResponse<Q>;
+    }>;
+    /**
+     * Only render children if the user is signed in.
+     * @see https://instantdb.com/docs/auth
+     *
+     * @example
+     *  <db.SignedIn>
+     *    <MyComponent />
+     *  </db.SignedIn>
+     *
+     */
+    SignedIn: React.FC<{
+        children: ReactNode;
+    }>;
+    /**
+     * Only render children if the user is signed out.
+     * @see https://instantdb.com/docs/auth
+     *
+     * @example
+     *  <db.SignedOut>
+     *    <MyComponent />
+     *  </db.SignedOut>
+     *
+     */
+    SignedOut: React.FC<{
+        children: ReactNode;
+    }>;
+}
+//# sourceMappingURL=InstantReactAbstractDatabase.d.ts.map

package/dist/esm/InstantReactAbstractDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstantReactAbstractDatabase.d.ts","sourceRoot":"","sources":["../../src/InstantReactAbstractDatabase.tsx"],"names":[],"mappings":"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"}

package/dist/esm/InstantReactAbstractDatabase.js

@@ -0,0 +1,320 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { txInit, init as core_init, InstantError, } from '@instantdb/core';
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore, } from 'react';
+import { useQueryInternal } from "./useQuery.js";
+import { InstantReactRoom, rooms } from "./InstantReactRoom.js";
+const defaultAuthState = {
+    isLoading: true,
+    user: undefined,
+    error: undefined,
+};
+export default class InstantReactAbstractDatabase {
+    constructor(config, versions) {
+        this.tx = txInit();
+        /**
+         * Returns a unique ID for a given `name`. It's stored in local storage,
+         * so you will get the same ID across sessions.
+         *
+         * This is useful for generating IDs that could identify a local device or user.
+         *
+         * @example
+         *  const deviceId = await db.getLocalId('device');
+         */
+        this.getLocalId = (name) => {
+            return this.core.getLocalId(name);
+        };
+        /**
+         * A hook that returns a unique ID for a given `name`. localIds are
+         * stored in local storage, so you will get the same ID across sessions.
+         *
+         * Initially returns `null`, and then loads the localId.
+         *
+         * @example
+         * const deviceId = db.useLocalId('device');
+         * if (!deviceId) return null; // loading
+         * console.log('Device ID:', deviceId)
+         */
+        this.useLocalId = (name) => {
+            const [localId, setLocalId] = useState(null);
+            useEffect(() => {
+                let mounted = true;
+                const f = () => __awaiter(this, void 0, void 0, function* () {
+                    const id = yield this.getLocalId(name);
+                    if (!mounted)
+                        return;
+                    setLocalId(id);
+                });
+                f();
+                return;
+            }, [name]);
+            return localId;
+        };
+        /**
+         * Hooks for working with rooms
+         *
+         * @see https://instantdb.com/docs/presence-and-topics
+         *
+         * @example
+         *  const room = db.room('chat', roomId);
+         *  const { peers } = db.rooms.usePresence(room);
+         *  const publish = db.rooms.usePublishTopic(room, 'emoji');
+         *  // ...
+         */
+        this.rooms = rooms;
+        /**
+         * Use this to write data! You can create, update, delete, and link objects
+         *
+         * @see https://instantdb.com/docs/instaml
+         *
+         * @example
+         *   // Create a new object in the `goals` namespace
+         *   const goalId = id();
+         *   db.transact(db.tx.goals[goalId].update({title: "Get fit"}))
+         *
+         *   // Update the title
+         *   db.transact(db.tx.goals[goalId].update({title: "Get super fit"}))
+         *
+         *   // Delete it
+         *   db.transact(db.tx.goals[goalId].delete())
+         *
+         *   // Or create an association:
+         *   todoId = id();
+         *   db.transact([
+         *    db.tx.todos[todoId].update({ title: 'Go on a run' }),
+         *    db.tx.goals[goalId].link({todos: todoId}),
+         *  ])
+         */
+        this.transact = (chunks) => {
+            return this.core.transact(chunks);
+        };
+        /**
+         * Use this to query your data!
+         *
+         * @see https://instantdb.com/docs/instaql
+         *
+         * @example
+         *   // listen to all goals
+         *   const { isLoading, error, data } = db.useQuery({ goals: {} });
+         *
+         *   // goals where the title is "Get Fit"
+         *   const { isLoading, error, data } = db.useQuery({
+         *     goals: { $: { where: { title: 'Get Fit' } } },
+         *   });
+         *
+         *   // all goals, _alongside_ their todos
+         *   const { isLoading, error, data } = db.useQuery({
+         *     goals: { todos: {} },
+         *   });
+         *
+         *   // skip if `user` is not logged in
+         *   const { isLoading, error, data } = db.useQuery(
+         *     auth.user ? { goals: {} } : null,
+         *   );
+         */
+        this.useQuery = (query, opts) => {
+            return useQueryInternal(this.core, query, opts).state;
+        };
+        /**
+         * Listen for the logged in state. This is useful
+         * for deciding when to show a login screen.
+         *
+         * Check out the docs for an example `Login` component too!
+         *
+         * @see https://instantdb.com/docs/auth
+         * @example
+         *  function App() {
+         *    const { isLoading, user, error } = db.useAuth()
+         *    if (isLoading) {
+         *      return <div>Loading...</div>
+         *    }
+         *    if (error) {
+         *      return <div>Uh oh! {error.message}</div>
+         *    }
+         *    if (user) {
+         *      return <Main user={user} />
+         *    }
+         *    return <Login />
+         *  }
+         *
+         */
+        this.useAuth = () => {
+            // 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(this.core._reactor._currentUserCached);
+            // Similar to `resultCacheRef`, `useSyncExternalStore` will unsubscribe
+            // if `subscribe` changes, so we use `useCallback` to memoize the function.
+            const subscribe = useCallback((cb) => {
+                const unsubscribe = this.core.subscribeAuth((auth) => {
+                    resultCacheRef.current = Object.assign({ isLoading: false }, auth);
+                    cb();
+                });
+                return unsubscribe;
+            }, []);
+            const state = useSyncExternalStore(subscribe, () => resultCacheRef.current, () => defaultAuthState);
+            return state;
+        };
+        /**
+         * Subscribe to the currently logged in user.
+         * If the user is not logged in, this hook with throw an Error.
+         * You will want to protect any calls of this hook with a
+         * <db.SignedIn> component, or your own logic based on db.useAuth()
+         *
+         * @see https://instantdb.com/docs/auth
+         * @throws Error indicating user not signed in
+         * @example
+         *  function UserDisplay() {
+         *    const user = db.useUser()
+         *    return <div>Logged in as: {user.email}</div>
+         *  }
+         *
+         *  <db.SignedIn>
+         *    <UserDisplay />
+         *  </db.SignedIn>
+         *
+         */
+        this.useUser = () => {
+            const { user } = this.useAuth();
+            if (!user) {
+                throw new InstantError('useUser must be used within an auth-protected route');
+            }
+            return user;
+        };
+        /**
+         * Listen for connection status changes to Instant. Use this for things like
+         * showing connection state to users
+         *
+         * @see https://www.instantdb.com/docs/patterns#connection-status
+         * @example
+         *  function App() {
+         *    const status = db.useConnectionStatus()
+         *    const connectionState =
+         *      status === 'connecting' || status === 'opened'
+         *        ? 'authenticating'
+         *      : status === 'authenticated'
+         *        ? 'connected'
+         *      : status === 'closed'
+         *        ? 'closed'
+         *      : status === 'errored'
+         *        ? 'errored'
+         *      : 'unexpected state';
+         *
+         *    return <div>Connection state: {connectionState}</div>
+         *  }
+         */
+        this.useConnectionStatus = () => {
+            const statusRef = useRef(this.core._reactor.status);
+            const subscribe = useCallback((cb) => {
+                const unsubscribe = this.core.subscribeConnectionStatus((newStatus) => {
+                    if (newStatus !== statusRef.current) {
+                        statusRef.current = newStatus;
+                        cb();
+                    }
+                });
+                return unsubscribe;
+            }, []);
+            const status = useSyncExternalStore(subscribe, () => statusRef.current, 
+            // For SSR, always return 'connecting' as the initial state
+            () => 'connecting');
+            return status;
+        };
+        /**
+         * Use this for one-off queries.
+         * Returns local data if available, otherwise fetches from the server.
+         * Because we want to avoid stale data, this method will throw an error
+         * if the user is offline or there is no active connection to the server.
+         *
+         * @see https://instantdb.com/docs/instaql
+         *
+         * @example
+         *
+         *  const resp = await db.queryOnce({ goals: {} });
+         *  console.log(resp.data.goals)
+         */
+        this.queryOnce = (query, opts) => {
+            return this.core.queryOnce(query, opts);
+        };
+        /**
+         * Only render children if the user is signed in.
+         * @see https://instantdb.com/docs/auth
+         *
+         * @example
+         *  <db.SignedIn>
+         *    <MyComponent />
+         *  </db.SignedIn>
+         *
+         */
+        this.SignedIn = ({ children }) => {
+            const auth = this.useAuth();
+            if (auth.isLoading || auth.error || !auth.user)
+                return null;
+            return _jsx(_Fragment, { children: children });
+        };
+        /**
+         * Only render children if the user is signed out.
+         * @see https://instantdb.com/docs/auth
+         *
+         * @example
+         *  <db.SignedOut>
+         *    <MyComponent />
+         *  </db.SignedOut>
+         *
+         */
+        this.SignedOut = ({ children }) => {
+            const auth = this.useAuth();
+            if (auth.isLoading || auth.error || auth.user)
+                return null;
+            return _jsx(_Fragment, { children: children });
+        };
+        this.core = core_init(config, 
+        // @ts-expect-error because TS can't resolve subclass statics
+        this.constructor.Storage, 
+        // @ts-expect-error because TS can't resolve subclass statics
+        this.constructor.NetworkListener, versions, 
+        // @ts-expect-error because TS can't resolve subclass statics
+        this.constructor.EventSourceImpl);
+        this._core = this.core;
+        this.auth = this.core.auth;
+        this.storage = this.core.storage;
+    }
+    /**
+     * Obtain a handle to a room, which allows you to listen to topics and presence data
+     *
+     * If you don't provide a `type` or `id`, Instant will default to `_defaultRoomType` and `_defaultRoomId`
+     * as the room type and id, respectively.
+     *
+     * @see https://instantdb.com/docs/presence-and-topics
+     *
+     * @example
+     *  const room = db.room('chat', roomId);
+     *  const { peers } = db.rooms.usePresence(room);
+     */
+    room(type = '_defaultRoomType', id = '_defaultRoomId') {
+        return new InstantReactRoom(this.core, type, id);
+    }
+    /**
+     * One time query for the logged in state. This is useful
+     * for scenarios where you want to know the current auth
+     * state without subscribing to changes.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   const user = await db.getAuth();
+     *   console.log('logged in as', user.email)
+     */
+    getAuth() {
+        return this.core.getAuth();
+    }
+}
+//# sourceMappingURL=InstantReactAbstractDatabase.js.map