@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,22 @@
+import { id, tx, lookup, i, 
+// error
+InstantAPIError, 
+// sync table enums
+SyncTableCallbackEventType, setInstantWarningsEnabled, StoreInterface, createInstantRouteHandler, } from '@instantdb/core';
+import { InstantReactAbstractDatabase } from '@instantdb/react-common';
+import InstantReactWebDatabase from './InstantReactWebDatabase.js';
+import { init, init_experimental } from './init.js';
+import { Cursors } from './Cursors.js';
+export { id, tx, lookup, init, init_experimental, InstantReactWebDatabase, Cursors, i, 
+// error
+InstantAPIError, 
+// internal
+InstantReactAbstractDatabase, 
+// sync table enums
+SyncTableCallbackEventType, 
+// warnings
+setInstantWarningsEnabled, 
+// custom store
+StoreInterface, 
+// Server helper
+createInstantRouteHandler, };

package/node_modules/@instantdb/react/dist/esm/init.d.ts

@@ -0,0 +1,40 @@
+import type { InstantConfig, InstantSchemaDef, InstantUnknownSchema } from '@instantdb/core';
+import InstantReactWebDatabase from './InstantReactWebDatabase.ts';
+/**
+ *
+ * The first step: init your application!
+ *
+ * Visit https://instantdb.com/dash to get your `appId` :)
+ *
+ * @example
+ *  import { init } from "@instantdb/react"
+ *
+ *  const db = init({ appId: "my-app-id" })
+ *
+ *  // You can also provide a schema for type safety and editor autocomplete!
+ *
+ *  import { init } from "@instantdb/react"
+ *  import schema from ""../instant.schema.ts";
+ *
+ *  const db = init({ appId: "my-app-id", schema })
+ *
+ *  // To learn more: https://instantdb.com/docs/modeling-data
+ */
+export declare function init<Schema extends InstantSchemaDef<any, any, any> = InstantUnknownSchema, UseDates extends boolean = false>(config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+    useDateObjects?: UseDates;
+}): InstantReactWebDatabase<Schema, UseDates, InstantConfig<Schema, UseDates>>;
+/**
+ * @deprecated
+ * `init_experimental` is deprecated. You can replace it with `init`.
+ *
+ * @example
+ *
+ * // Before
+ * import { init_experimental } from "@instantdb/react"
+ * const db = init_experimental({  ...  });
+ *
+ * // After
+ * import { init } from "@instantdb/react"
+ * const db = init({ ...  });
+ */
+export declare const init_experimental: typeof init;

package/node_modules/@instantdb/react/dist/esm/init.js

@@ -0,0 +1,49 @@
+import InstantReactWebDatabase from './InstantReactWebDatabase.js';
+import version from './version.js';
+/**
+ *
+ * The first step: init your application!
+ *
+ * Visit https://instantdb.com/dash to get your `appId` :)
+ *
+ * @example
+ *  import { init } from "@instantdb/react"
+ *
+ *  const db = init({ appId: "my-app-id" })
+ *
+ *  // You can also provide a schema for type safety and editor autocomplete!
+ *
+ *  import { init } from "@instantdb/react"
+ *  import schema from ""../instant.schema.ts";
+ *
+ *  const db = init({ appId: "my-app-id", schema })
+ *
+ *  // To learn more: https://instantdb.com/docs/modeling-data
+ */
+export function init(
+// Allows config with missing `useDateObjects`, but keeps `UseDates`
+// as a non-nullable in the InstantConfig type.
+config) {
+    const configStrict = {
+        ...config,
+        useDateObjects: (config.useDateObjects ?? false),
+    };
+    return new InstantReactWebDatabase(configStrict, {
+        '@instantdb/react': version,
+    });
+}
+/**
+ * @deprecated
+ * `init_experimental` is deprecated. You can replace it with `init`.
+ *
+ * @example
+ *
+ * // Before
+ * import { init_experimental } from "@instantdb/react"
+ * const db = init_experimental({  ...  });
+ *
+ * // After
+ * import { init } from "@instantdb/react"
+ * const db = init({ ...  });
+ */
+export const init_experimental = init;

package/node_modules/@instantdb/react/dist/esm/next-ssr/HydrationStreamProvider.d.ts

@@ -0,0 +1,65 @@
+export declare const isServer: boolean;
+import * as React from 'react';
+interface DataTransformer {
+    serialize: (object: any) => any;
+    deserialize: (object: any) => any;
+}
+interface HydrationStreamContext<TShape> {
+    id: string;
+    stream: {
+        /**
+         * **Server method**
+         * Push a new entry to the stream
+         * Will be ignored on the client
+         */
+        push: (...shape: Array<TShape>) => void;
+    };
+}
+export interface HydrationStreamProviderProps<TShape> {
+    children: React.ReactNode;
+    /**
+     * Optional transformer to serialize/deserialize the data
+     * Example devalue, superjson et al
+     */
+    transformer?: DataTransformer;
+    /**
+     * **Client method**
+     * Called in the browser when new entries are received
+     */
+    onEntries: (entries: Array<TShape>) => void;
+    /**
+     * **Server method**
+     * onFlush is called on the server when the cache is flushed
+     */
+    onFlush?: () => Array<TShape>;
+    /**
+     * A nonce that'll allow the inline script to be executed when Content Security Policy is enforced
+     */
+    nonce?: string;
+}
+export declare function createHydrationStreamProvider<TShape>(): {
+    Provider: (props: {
+        children: React.ReactNode;
+        /**
+         * Optional transformer to serialize/deserialize the data
+         * Example devalue, superjson et al
+         */
+        transformer?: DataTransformer;
+        /**
+         * **Client method**
+         * Called in the browser when new entries are received
+         */
+        onEntries: (entries: Array<TShape>) => void;
+        /**
+         * **Server method**
+         * onFlush is called on the server when the cache is flushed
+         */
+        onFlush?: () => Array<TShape>;
+        /**
+         * A nonce that'll allow the inline script to be executed when Content Security Policy is enforced
+         */
+        nonce?: string;
+    }) => React.JSX.Element;
+    context: React.Context<HydrationStreamContext<TShape>>;
+};
+export {};

package/node_modules/@instantdb/react/dist/esm/next-ssr/HydrationStreamProvider.js

@@ -0,0 +1,96 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+// This allows us to send serialized json from the server to the client using 'useServerInsertedHTML'
+// We are allowed to send whatever json we want, however it must be triggered at the same time as the client is recieving new html to display
+// after a suspsense boundary resolves
+// We do this to send a list of triples and attrs for each query that the server made so they can be pre-filled on the client render.
+// useServerInsertedHTML is called whenever a suspense boundary resolves, resulting in new html being streamed down to the client.
+export const isServer = typeof window === 'undefined' || 'Deno' in globalThis;
+import { useServerInsertedHTML } from 'next/navigation.js';
+import * as React from 'react';
+import { htmlEscapeJsonString } from './htmlescape.js';
+const serializedSymbol = Symbol('serialized');
+export function createHydrationStreamProvider() {
+    const context = React.createContext(null);
+    /**
+  
+     * 1. (Happens on server): `useServerInsertedHTML()` is called **on the server** whenever a `Suspense`-boundary completes
+     *    - This means that we might have some new entries in the cache that needs to be flushed
+     *    - We pass these to the client by inserting a `<script>`-tag where we do `window[id].push(serializedVersionOfCache)`
+     * 2. (Happens in browser) In `useEffect()`:
+     *   - We check if `window[id]` is set to an array and call `push()` on all the entries which will call `onEntries()` with the new entries
+     *   - We replace `window[id]` with a `push()`-method that will be called whenever new entries are received
+     **/
+    function UseClientHydrationStreamProvider(props) {
+        // unique id for the cache provider
+        const id = `__RQ${React.useId()}`;
+        const idJSON = htmlEscapeJsonString(JSON.stringify(id));
+        const [transformer] = React.useState(() => (props.transformer ?? {
+            // noop
+            serialize: (obj) => obj,
+            deserialize: (obj) => obj,
+        }));
+        // <server stuff>
+        const [stream] = React.useState(() => {
+            if (!isServer) {
+                return {
+                    push() {
+                        // no-op on the client
+                    },
+                };
+            }
+            return [];
+        });
+        const count = React.useRef(0);
+        useServerInsertedHTML(() => {
+            // This only happens on the server
+            stream.push(...(props.onFlush?.() ?? []));
+            if (!stream.length) {
+                return null;
+            }
+            const serializedCacheArgs = stream
+                .map((entry) => transformer.serialize(entry))
+                .map((entry) => JSON.stringify(entry))
+                .join(',');
+            // Flush stream
+            // eslint-disable-next-line react-hooks/immutability
+            stream.length = 0;
+            const html = [
+                `window[${idJSON}] = window[${idJSON}] || [];`,
+                `window[${idJSON}].push(${htmlEscapeJsonString(serializedCacheArgs)});`,
+            ];
+            return (_jsx("script", { nonce: props.nonce, dangerouslySetInnerHTML: {
+                    __html: html.join(''),
+                } }, count.current++));
+        });
+        // </server stuff>
+        // <client stuff>
+        // Setup and run the onEntries handler on the client only, but do it during
+        // the initial render so children have access to the data immediately
+        // This is important to avoid the client suspending during the initial render
+        // if the data has not yet been hydrated.
+        if (!isServer) {
+            const win = window;
+            if (!win[id]?.initialized) {
+                // Client: consume cache:
+                const onEntries = (...serializedEntries) => {
+                    const entries = serializedEntries.map((serialized) => transformer.deserialize(serialized));
+                    props.onEntries(entries);
+                };
+                const winStream = win[id] ?? [];
+                onEntries(...winStream);
+                // eslint-disable-next-line react-hooks/immutability
+                win[id] = {
+                    initialized: true,
+                    push: onEntries,
+                };
+            }
+        }
+        // </client stuff>
+        return (_jsx(context.Provider, { value: { stream, id }, children: props.children }));
+    }
+    return {
+        Provider: UseClientHydrationStreamProvider,
+        context,
+    };
+}

package/node_modules/@instantdb/react/dist/esm/next-ssr/InstantNextDatabase.d.ts

@@ -0,0 +1,11 @@
+import { AuthState, InstantSchemaDef, InstaQLResponse, PageInfoResponse, RuleParams, ValidQuery } from '@instantdb/core';
+import InstantReactWebDatabase from '../InstantReactWebDatabase.ts';
+export declare class InstantNextDatabase<Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean> extends InstantReactWebDatabase<Schema, UseDates> {
+    useSuspenseQuery: <Q extends ValidQuery<Q, Schema>>(q: Q, opts?: {
+        ruleParams: RuleParams;
+    }) => {
+        data: InstaQLResponse<Schema, Q, NonNullable<UseDates>>;
+        pageInfo?: PageInfoResponse<Q>;
+    };
+    useAuth: () => AuthState;
+}

package/node_modules/@instantdb/react/dist/esm/next-ssr/InstantNextDatabase.js

@@ -0,0 +1,31 @@
+import InstantReactWebDatabase from '../InstantReactWebDatabase.js';
+import { useContext } from 'react';
+import { SuspsenseQueryContext } from './InstantSuspenseProvider.js';
+export class InstantNextDatabase extends InstantReactWebDatabase {
+    useSuspenseQuery = (q, opts) => {
+        const ctx = useContext(SuspsenseQueryContext);
+        if (!ctx) {
+            throw new Error('useSuspenseQuery must be used within a SuspenseQueryProvider');
+        }
+        return ctx.useSuspenseQuery(q, opts);
+    };
+    useAuth = () => {
+        const ctx = useContext(SuspsenseQueryContext);
+        const realAuthResult = this._useAuth();
+        if (!ctx) {
+            return realAuthResult;
+        }
+        const { ssrUser } = ctx;
+        if (ssrUser === undefined) {
+            return realAuthResult;
+        }
+        if (realAuthResult.isLoading) {
+            return {
+                error: undefined,
+                isLoading: false,
+                user: ssrUser ?? undefined, // null -> undefined for the response
+            };
+        }
+        return realAuthResult;
+    };
+}

package/node_modules/@instantdb/react/dist/esm/next-ssr/InstantSuspenseProvider.d.ts

@@ -0,0 +1,24 @@
+import { InstantSchemaDef, InstaQLResponse, PageInfoResponse, RuleParams, User, ValidQuery } from '@instantdb/core';
+import InstantReactWebDatabase from '../InstantReactWebDatabase.ts';
+type InstantSuspenseProviderProps<Schema extends InstantSchemaDef<any, any, any>> = {
+    nonce?: string;
+    children: React.ReactNode;
+    db: InstantReactWebDatabase<Schema, any>;
+    user?: User | null;
+};
+type SuspenseQueryContextValue = {
+    useSuspenseQuery: (query: any, opts?: SuspenseQueryOpts) => any;
+    ssrUser: User | null | undefined;
+};
+export declare const SuspsenseQueryContext: import("react").Context<SuspenseQueryContextValue | null>;
+export declare const createUseSuspenseQuery: <Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean>(_db: InstantReactWebDatabase<Schema, UseDates>) => (<Q extends ValidQuery<Q, Schema>>(q: Q, opts?: {
+    ruleParams: RuleParams;
+}) => {
+    data: InstaQLResponse<Schema, Q, NonNullable<UseDates>>;
+    pageInfo?: PageInfoResponse<Q>;
+});
+type SuspenseQueryOpts = {
+    ruleParams: RuleParams;
+};
+export declare const InstantSuspenseProvider: (props: InstantSuspenseProviderProps<any>) => import("react").JSX.Element;
+export {};

package/node_modules/@instantdb/react/dist/esm/next-ssr/InstantSuspenseProvider.js

@@ -0,0 +1,162 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+// InstantSuspenseProvider can only be used in a client context so this prevents errors from trying to use it in a server component.
+import { FrameworkClient, } from '@instantdb/core';
+import { createHydrationStreamProvider, isServer, } from './HydrationStreamProvider.js';
+import { createContext, useCallback, useContext, useMemo, useRef, useState, useEffect, } from 'react';
+import { useQueryInternal, } from '@instantdb/react-common';
+const stream = createHydrationStreamProvider();
+export const SuspsenseQueryContext = createContext(null);
+// Creates a typed useSuspense hook
+export const createUseSuspenseQuery = (_db) => {
+    return (q, opts) => {
+        const ctx = useContext(SuspsenseQueryContext);
+        if (!ctx) {
+            throw new Error('useSuspenseQuery must be used within a SuspenseQueryProvider');
+        }
+        return ctx.useSuspenseQuery(q, opts);
+    };
+};
+function makeUseSuspenseQueryServer(client) {
+    return function useSuspenseQueryServer(query, opts) {
+        let entry = client.getExistingResultForQuery(query, opts);
+        if (!entry) {
+            entry = client.query(query, opts);
+        }
+        if (entry.status === 'pending') {
+            throw entry.promise;
+        }
+        if (entry.status === 'error') {
+            throw entry.error;
+        }
+        if (entry.status === 'success') {
+            switch (entry.type) {
+                case 'session': {
+                    return entry.data;
+                }
+                case 'http': {
+                    const data = entry.data;
+                    const result = client.completeIsomorphic(query, data.triples, data.attrs, data.pageInfo);
+                    return result;
+                }
+            }
+        }
+    };
+}
+function makeUseSuspenseQueryClient(db, client) {
+    function getEntry(query, opts, allowFetch) {
+        const entry = client.getExistingResultForQuery(query, opts);
+        if (entry?.status === 'pending') {
+            throw entry.promise;
+        }
+        if (entry?.status === 'error') {
+            throw entry.error;
+        }
+        if (entry?.status === 'success') {
+            switch (entry.type) {
+                case 'session': {
+                    return entry.data;
+                }
+                case 'http': {
+                    const data = entry.data;
+                    const result = client.completeIsomorphic(query, data.triples, data.attrs, data.pageInfo);
+                    return result;
+                }
+            }
+        }
+        if (allowFetch) {
+            const promise = client.queryClient(query, opts);
+            throw promise;
+        }
+    }
+    return function useSuspenseQueryClient(query, opts) {
+        const useQueryResult = useQueryInternal(db.core, query, opts, 
+        // Returns the server result for useSyncExternalStore
+        () => {
+            try {
+                const res = getEntry(query, opts, false);
+                return res;
+            }
+            catch (throwable) {
+                return { error: throwable };
+            }
+        });
+        const hasData = !!useQueryResult.state.data;
+        const queryHash = useQueryResult.queryHash;
+        useEffect(() => {
+            if (hasData) {
+                // We have a newer result, so remove the cached SSR or suspended
+                // result from the framework client cache
+                client.removeCachedQueryResult(queryHash);
+            }
+        }, [hasData, queryHash]);
+        if (useQueryResult.state.data) {
+            return {
+                data: useQueryResult.state.data,
+                pageInfo: useQueryResult.state.pageInfo,
+            };
+        }
+        if (useQueryResult.state.error) {
+            throw useQueryResult.state.error;
+        }
+        return getEntry(query, opts, true);
+    };
+}
+function createFrameworkClient(db, user) {
+    if (isServer) {
+        if (user && !user.refresh_token) {
+            throw new Error('User must have a refresh_token field. Recieved: ' +
+                JSON.stringify(user, null, 2));
+        }
+        return new FrameworkClient({
+            token: user?.refresh_token,
+            db: db.core,
+        });
+    }
+    // On the client, make sure we only have a single framework
+    // in case our suspense provider gets unmounted
+    const existing = db.core._reactor._frameworkClient;
+    if (existing) {
+        return existing;
+    }
+    const client = new FrameworkClient({ db: db.core });
+    db.core._reactor.setFrameworkClient(client);
+    return client;
+}
+export const InstantSuspenseProvider = (props) => {
+    if (!props.db) {
+        throw new Error('Must provide db to InstantSuspenseProvider');
+    }
+    const db = props.db;
+    const [trackedKeys] = useState(() => new Set());
+    const clientRef = useRef(createFrameworkClient(props.db, props.user));
+    if (isServer) {
+        clientRef.current.subscribe((result) => {
+            const { queryHash } = result;
+            trackedKeys.add(queryHash);
+        });
+    }
+    const useSuspenseQuery = useCallback(isServer
+        ? makeUseSuspenseQueryServer(clientRef.current)
+        : makeUseSuspenseQueryClient(db, clientRef.current), []);
+    const contextValue = useMemo(() => {
+        return { useSuspenseQuery, ssrUser: props.user };
+    }, [useSuspenseQuery, props.user]);
+    return (_jsx(SuspsenseQueryContext.Provider, { value: contextValue, children: _jsx(stream.Provider, { nonce: props.nonce, onFlush: () => {
+                const toSend = [];
+                for (const [key, value] of clientRef.current.resultMap.entries()) {
+                    if (trackedKeys.has(key) && value.status === 'success') {
+                        toSend.push({
+                            queryKey: key,
+                            value: value.data,
+                        });
+                    }
+                }
+                trackedKeys.clear();
+                return toSend;
+            }, onEntries: (entries) => {
+                entries.forEach((entry) => {
+                    clientRef.current.addQueryResult(entry.queryKey, entry.value);
+                });
+            }, children: props.children }) }));
+};

package/node_modules/@instantdb/react/dist/esm/next-ssr/getUserFromInstantCookie.d.ts

@@ -0,0 +1,9 @@
+import { User } from '@instantdb/core';
+/**
+ * @deprecated Please use `getUnverifiedUserFromInstantCookie` instead
+ */
+export declare const getUserFromInstantCookie: (appId: string) => Promise<User | null>;
+/**
+ * Parses a user object from current Next.JS request context's cookies.
+ */
+export declare const getUnverifiedUserFromInstantCookie: (appId: string) => Promise<User | null>;

package/node_modules/@instantdb/react/dist/esm/next-ssr/getUserFromInstantCookie.js

@@ -0,0 +1,16 @@
+import { cookies } from 'next/headers.js';
+/**
+ * @deprecated Please use `getUnverifiedUserFromInstantCookie` instead
+ */
+export const getUserFromInstantCookie = async (appId) => {
+    return getUnverifiedUserFromInstantCookie(appId);
+};
+/**
+ * Parses a user object from current Next.JS request context's cookies.
+ */
+export const getUnverifiedUserFromInstantCookie = async (appId) => {
+    const cookieStore = await cookies();
+    const userJSON = cookieStore.get('instant_user_' + appId);
+    const user = userJSON ? JSON.parse(decodeURIComponent(userJSON.value)) : null;
+    return user;
+};

package/node_modules/@instantdb/react/dist/esm/next-ssr/htmlescape.d.ts

@@ -0,0 +1,2 @@
+export declare const ESCAPE_REGEX: RegExp;
+export declare function htmlEscapeJsonString(str: string): string;

package/node_modules/@instantdb/react/dist/esm/next-ssr/htmlescape.js

@@ -0,0 +1,20 @@
+// --------------------------------------------------------------------------------
+//
+// copied from
+// https://github.com/vercel/next.js/blob/6bc07792a4462a4bf921a72ab30dc4ab2c4e1bda/packages/next/src/server/htmlescape.ts
+// License: https://github.com/vercel/next.js/blob/6bc07792a4462a4bf921a72ab30dc4ab2c4e1bda/packages/next/license.md
+//
+// --------------------------------------------------------------------------------
+// This utility is based on https://github.com/zertosh/htmlescape
+// License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
+const ESCAPE_LOOKUP = {
+    '&': '\\u0026',
+    '>': '\\u003e',
+    '<': '\\u003c',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029',
+};
+export const ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+export function htmlEscapeJsonString(str) {
+    return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+}

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

@@ -0,0 +1,29 @@
+import { InstantConfig, InstantSchemaDef, InstantUnknownSchema } from '@instantdb/core';
+import { InstantNextDatabase } from './InstantNextDatabase.tsx';
+export { getUnverifiedUserFromInstantCookie, getUserFromInstantCookie, } from './getUserFromInstantCookie.ts';
+export { InstantNextDatabase } from './InstantNextDatabase.tsx';
+export { InstantSuspenseProvider } from './InstantSuspenseProvider.tsx';
+export { createInstantRouteHandler } from '@instantdb/core';
+/**
+ *
+ * The first step: init your application!
+ *
+ * Visit https://instantdb.com/dash to get your `appId` :)
+ *
+ * @example
+ *  import { init } from "@instantdb/react"
+ *
+ *  const db = init({ appId: "my-app-id" })
+ *
+ *  // You can also provide a schema for type safety and editor autocomplete!
+ *
+ *  import { init } from "@instantdb/react"
+ *  import schema from ""../instant.schema.ts";
+ *
+ *  const db = init({ appId: "my-app-id", schema })
+ *
+ *  // To learn more: https://instantdb.com/docs/modeling-data
+ */
+export declare function init<Schema extends InstantSchemaDef<any, any, any> = InstantUnknownSchema, UseDates extends boolean = false>(config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+    useDateObjects?: UseDates;
+}): InstantNextDatabase<Schema, UseDates>;

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

@@ -0,0 +1,34 @@
+import version from '../version.js';
+import { InstantNextDatabase } from './InstantNextDatabase.js';
+export { getUnverifiedUserFromInstantCookie, getUserFromInstantCookie, } from './getUserFromInstantCookie.js';
+export { InstantNextDatabase } from './InstantNextDatabase.js';
+export { InstantSuspenseProvider } from './InstantSuspenseProvider.js';
+export { createInstantRouteHandler } from '@instantdb/core';
+/**
+ *
+ * The first step: init your application!
+ *
+ * Visit https://instantdb.com/dash to get your `appId` :)
+ *
+ * @example
+ *  import { init } from "@instantdb/react"
+ *
+ *  const db = init({ appId: "my-app-id" })
+ *
+ *  // You can also provide a schema for type safety and editor autocomplete!
+ *
+ *  import { init } from "@instantdb/react"
+ *  import schema from ""../instant.schema.ts";
+ *
+ *  const db = init({ appId: "my-app-id", schema })
+ *
+ *  // To learn more: https://instantdb.com/docs/modeling-data
+ */
+export function init(
+// Allows config with missing `useDateObjects`, but keeps `UseDates`
+// as a non-nullable in the InstantConfig type.
+config) {
+    return new InstantNextDatabase(config, {
+        '@instantdb/react': version,
+    });
+}

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

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

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

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

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

@@ -0,0 +1,24 @@
+{
+  "name": "@instantdb/react",
+  "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/react-common": "0.0.0",
+    "@instantdb/version": "0.0.0",
+    "eventsource": "5.1.3"
+  },
+  "peerDependencies": {
+    "react": ">=16"
+  }
+}