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

package/.tshy/build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "../src",
+    "module": "nodenext",
+    "moduleResolution": "nodenext"
+  }
+}

package/.tshy/commonjs.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./build.json",
+  "include": [
+    "../src/**/*.ts",
+    "../src/**/*.cts",
+    "../src/**/*.tsx",
+    "../src/**/*.json"
+  ],
+  "exclude": [
+    "../src/**/*.mts",
+    "../src/package.json"
+  ],
+  "compilerOptions": {
+    "outDir": "../.tshy-build/commonjs"
+  }
+}

package/.tshy/esm.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./build.json",
+  "include": [
+    "../src/**/*.ts",
+    "../src/**/*.mts",
+    "../src/**/*.tsx",
+    "../src/**/*.json"
+  ],
+  "exclude": [
+    "../src/package.json"
+  ],
+  "compilerOptions": {
+    "outDir": "../.tshy-build/esm"
+  }
+}

package/README.md

@@ -0,0 +1,53 @@
+<p align="center">
+  <a href="https://instantdb.com">
+    <img alt="Shows the Instant logo" src="https://instantdb.com/img/icon/android-chrome-512x512.png" width="10%">
+  </a>
+  <h1 align="center">@instantdb/react-common</h1>
+</p>
+
+<p align="center">
+  <a 
+    href="https://discord.com/invite/VU53p7uQcE" >
+    <img height=20 src="https://img.shields.io/discord/1031957483243188235" />
+  </a>
+  <img src="https://img.shields.io/github/stars/instantdb/instant" alt="stars">
+</p>
+
+<p align="center">
+   <a href="https://instantdb.com/dash">Get Started</a> ·
+   <a href="https://instantdb.com/examples">Examples</a> ·
+   <a href="https://instantdb.com/docs">Docs</a> ·
+   <a href="https://discord.com/invite/VU53p7uQcE">Discord</a>
+<p>
+
+Welcome to [Instant's](http://instantdb.com) React common components for React and React Native.
+
+```javascript
+// ༼ つ ◕_◕ ༽つ Real-time Chat
+// ----------------------------------
+// * Updates instantly
+// * Multiplayer
+// * Works offline
+function Chat() {
+  // 1. Read
+  const { isLoading, error, data } = useQuery({
+    messages: {},
+  });
+
+  // 2. Write
+  const addMessage = (message) => {
+    transact(tx.messages[id()].update(message));
+  };
+
+  // 3. Render!
+  return <UI data={data} onAdd={addMessage} />;
+}
+```
+
+# Get Started
+
+Follow the [getting started](https://www.instantdb.com/docs) tutorial to set up a live React app in under 5 minutes!
+
+# Questions?
+
+If you have any questions, feel free to drop us a line on our [Discord](https://discord.com/invite/VU53p7uQcE)

package/dist/commonjs/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/commonjs/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/commonjs/InstantReactAbstractDatabase.js

@@ -0,0 +1,323 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const core_1 = require("@instantdb/core");
+const react_1 = require("react");
+const useQuery_ts_1 = require("./useQuery.js");
+const InstantReactRoom_ts_1 = require("./InstantReactRoom.js");
+const defaultAuthState = {
+    isLoading: true,
+    user: undefined,
+    error: undefined,
+};
+class InstantReactAbstractDatabase {
+    constructor(config, versions) {
+        this.tx = (0, core_1.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] = (0, react_1.useState)(null);
+            (0, react_1.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 = InstantReactRoom_ts_1.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 (0, useQuery_ts_1.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 = (0, react_1.useRef)(this.core._reactor._currentUserCached);
+            // Similar to `resultCacheRef`, `useSyncExternalStore` will unsubscribe
+            // if `subscribe` changes, so we use `useCallback` to memoize the function.
+            const subscribe = (0, react_1.useCallback)((cb) => {
+                const unsubscribe = this.core.subscribeAuth((auth) => {
+                    resultCacheRef.current = Object.assign({ isLoading: false }, auth);
+                    cb();
+                });
+                return unsubscribe;
+            }, []);
+            const state = (0, react_1.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 core_1.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 = (0, react_1.useRef)(this.core._reactor.status);
+            const subscribe = (0, react_1.useCallback)((cb) => {
+                const unsubscribe = this.core.subscribeConnectionStatus((newStatus) => {
+                    if (newStatus !== statusRef.current) {
+                        statusRef.current = newStatus;
+                        cb();
+                    }
+                });
+                return unsubscribe;
+            }, []);
+            const status = (0, react_1.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 (0, jsx_runtime_1.jsx)(jsx_runtime_1.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 (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
+        };
+        this.core = (0, core_1.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_ts_1.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();
+    }
+}
+exports.default = InstantReactAbstractDatabase;
+//# sourceMappingURL=InstantReactAbstractDatabase.js.map