@korajs/react 0.0.0-canary-20261008174129

package/dist/index.d.ts

@@ -0,0 +1,322 @@
+import { KoraAppLike as KoraAppLike$1, KoraContextValue as KoraContextValue$1, UseQueryOptions as UseQueryOptions$1, UseMutationOptions as UseMutationOptions$1, UseMutationResultBase, AuthSyncBinding, AuthSyncState } from '@korajs/core/bindings';
+import { Store, QueryStoreCache, CollectionRecord, QueryBuilder, CollectionAccessor } from '@korajs/store';
+import { SyncEngine, CursorInfo, SyncStatusInfo, AwarenessUser, AwarenessState } from '@korajs/sync';
+import { ReactNode } from 'react';
+import * as Y from 'yjs';
+
+type KoraAppLike = KoraAppLike$1<Store, SyncEngine, QueryStoreCache>;
+type KoraContextValue = KoraContextValue$1<Store, SyncEngine, QueryStoreCache>;
+/** Options for {@link useQuery} and {@link useQueryState}. */
+interface UseQueryOptions extends UseQueryOptions$1 {
+    /**
+     * When true (default), `useQuery` throws a failed query to the nearest error
+     * boundary. When false it keeps returning the last good rows; read the error with
+     * `useQueryState`. Ignored by `useQueryState`, which always returns the error.
+     */
+    throwOnError?: boolean;
+}
+/** Result of `useQueryState`. */
+interface UseQueryStateResult<T> {
+    /** The current rows (the last good rows while `error` is set). */
+    data: readonly T[];
+    /** The query's failure, or null. Cleared when results flow again. */
+    error: Error | null;
+    /** False until the first result for the current query arrived (always false on the server). */
+    ready: boolean;
+}
+type UseMutationOptions<TData, TArgs extends unknown[], TContext = void> = UseMutationOptions$1<TData, TArgs, TContext>;
+/**
+ * Props for the KoraProvider component.
+ *
+ * Accepts either an `app` instance (recommended, from createApp()) or
+ * explicit `store` + `syncEngine` props (advanced use case).
+ */
+interface KoraProviderProps {
+    app?: KoraAppLike;
+    store?: Store;
+    syncEngine?: SyncEngine | null;
+    fallback?: ReactNode;
+    children?: ReactNode;
+}
+interface UseMutationResult<TData, TArgs extends unknown[]> extends UseMutationResultBase<TData, TArgs> {
+    isLoading: boolean;
+    error: Error | null;
+}
+interface UseRichTextResult {
+    doc: Y.Doc;
+    text: Y.Text;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    ready: boolean;
+    error: Error | null;
+    cursors: CursorInfo[];
+    setCursor: (anchor: number, head: number) => void;
+    clearCursor: () => void;
+    /**
+     * True while local edits are not saved yet (a save pending or refused; see
+     * `error`). The edits stay in the document and the next edit saves them again.
+     */
+    hasUnsavedChanges: boolean;
+    /** Save the document now, for example after a refused save. */
+    retrySave: () => Promise<void>;
+    /** The full document state while edits are unsaved (for a recovery copy), else null. */
+    getUnsavedState: () => Uint8Array | null;
+}
+
+/**
+ * Provides Kora store and optional sync engine to all child components.
+ * Must wrap any component that uses Kora hooks (useQuery, useMutation, etc.).
+ */
+declare function KoraProvider({ app, store, syncEngine, fallback, children, }: KoraProviderProps): ReactNode;
+
+interface AuthBoundKoraProviderProps {
+    authClient: AuthSyncBinding;
+    createApp: (session: Extract<AuthSyncState, {
+        state: 'authenticated';
+    }>) => KoraAppLike & {
+        close(): Promise<void>;
+    };
+    signedOut?: ReactNode;
+    /**
+     * Rendered instead of the app while the session is locked (offline longer
+     * than the auth client's `maxOfflineGraceMs`, or the device clock moved
+     * backwards). The app and its local data stay open underneath; nothing is
+     * wiped. Defaults to `signedOut`.
+     */
+    locked?: ReactNode;
+    fallback?: ReactNode;
+    error?: (context: AuthBoundKoraErrorContext) => ReactNode;
+    children?: ReactNode;
+}
+interface AuthBoundKoraSession {
+    /** The authenticated identity only. Access tokens are deliberately omitted. */
+    userId: string;
+}
+interface AuthBoundKoraInitializationError {
+    /** Stable Kora/DOM error code suitable for application-owned copy and recovery UI. */
+    code: string;
+    name: string;
+    message: string;
+    /** Sanitized primitive metadata. Credential-shaped keys are always removed. */
+    metadata: Readonly<Record<string, string | number | boolean | null>>;
+    /** Sanitized Error for logging; custom credential-bearing properties are omitted. */
+    cause: Error;
+}
+interface AuthBoundKoraErrorContext {
+    error: AuthBoundKoraInitializationError;
+    retry(): void;
+    session: AuthBoundKoraSession;
+}
+/** Classify initialization failures without requiring applications to parse copy. */
+declare function classifyKoraInitializationError(error: unknown): AuthBoundKoraInitializationError;
+/**
+ * Owns the security-sensitive app lifetime for shared-browser applications.
+ * The previous app is fully closed before a different user's app is created,
+ * and no stale provider tree is rendered across that boundary.
+ */
+declare function AuthBoundKoraProvider({ authClient, createApp, signedOut, locked, fallback, error: renderError, children, }: AuthBoundKoraProviderProps): ReactNode;
+
+/**
+ * React hook that returns the Kora app instance from context.
+ *
+ * Use the generic parameter to cast to your typed app for full type inference:
+ *
+ * ```typescript
+ * // In your app setup:
+ * export const app = createApp({ schema: mySchema })
+ * export type App = typeof app
+ *
+ * // In components:
+ * const app = useApp<App>()
+ * app.todos.insert({ title: 'Hello' })  // fully typed
+ * const todos = useQuery(app.todos.where({ completed: false }))
+ * ```
+ *
+ * Requires `KoraProvider` to be initialized with the `app` prop.
+ * Throws if used outside of `KoraProvider` or without an `app` prop.
+ *
+ * @returns The KoraApp instance, typed as `T`
+ */
+declare function useApp<T extends KoraAppLike = KoraAppLike>(): T;
+
+/**
+ * React hook for reactive queries against the local Kora store.
+ *
+ * Returns the current rows synchronously (no loading state for local data) and
+ * re-renders only when the result set changes. The array keeps its identity while
+ * the result is unchanged. On the server (`renderToString`, Next.js App Router) and
+ * during hydration it returns `[]`; the rows arrive right after hydration.
+ *
+ * A query that fails (for example a where/orderBy on an unknown field) is thrown to
+ * the nearest React error boundary, so the failure is visible instead of an empty
+ * list. Pass `throwOnError: false`, or use {@link useQueryState}, to handle it inline.
+ *
+ * @param query - A query builder, for example `app.todos.where({ completed: false })`
+ * @param options - `enabled` (default true) and `throwOnError` (default true)
+ * @returns The current result rows
+ *
+ * @example
+ * ```tsx
+ * const todos = useQuery(app.todos.where({ completed: false }).orderBy('createdAt'))
+ * ```
+ */
+declare function useQuery<T = CollectionRecord>(query: QueryBuilder<T>, options?: UseQueryOptions): readonly T[];
+/**
+ * Like {@link useQuery}, but returns the error instead of throwing it.
+ *
+ * @param query - A query builder
+ * @param options - `enabled` (default true); `throwOnError` is ignored
+ * @returns `{ data, error, ready }`, the same object until one of them changes.
+ *   `ready` is false until the first result for the current query has arrived.
+ *
+ * @example
+ * ```tsx
+ * const { data: todos, error } = useQueryState(app.todos.where({ completed: false }))
+ * if (error) return <p role="alert">{error.message}</p>
+ * ```
+ */
+declare function useQueryState<T = CollectionRecord>(query: QueryBuilder<T>, options?: UseQueryOptions): UseQueryStateResult<T>;
+
+/**
+ * React hook for performing mutations against the local Kora store.
+ *
+ * `mutate`, `mutateAsync` and `reset` keep their identity for the component's lifetime
+ * (safe in effect deps and as memoized props), and the result object only changes when
+ * `isLoading` or `error` does. The latest `mutationFn` and `options` are always used.
+ *
+ * @param mutationFn - The mutation to run, for example `app.todos.insert`
+ * @param options - Optional lifecycle callbacks (`onMutate`, `onSuccess`, `onError`, `onSettled`)
+ * @returns `{ mutate, mutateAsync, isLoading, error, reset }`
+ *
+ * @example
+ * ```tsx
+ * const { mutate: addTodo, isLoading } = useMutation(app.todos.insert)
+ * return <button disabled={isLoading} onClick={() => addTodo({ title: 'New' })}>Add</button>
+ * ```
+ */
+declare function useMutation<TData, TArgs extends unknown[], TContext = void>(mutationFn: (...args: TArgs) => Promise<TData>, options?: UseMutationOptions<TData, TArgs, TContext>): UseMutationResult<TData, TArgs>;
+
+/**
+ * React hook for monitoring the sync engine's connection status.
+ *
+ * Re-renders only when the status payload changes. The returned object, and its nested
+ * `heldNodes`, `initialSync` and `blockedFailure` values, keep their identity while
+ * unchanged, so they are safe as effect or memo dependencies. Beyond `status` and
+ * `pendingOperations` it reports `heldOperations` / `heldNodes` (writes of another
+ * user waiting on this device), `localDurability` (`'degraded'` when the local
+ * database cannot persist) and `serverProtocolVersion` / `protocolDeprecated`.
+ *
+ * @returns The current {@link SyncStatusInfo}
+ *
+ * @example
+ * ```tsx
+ * const { status, pendingOperations, localDurability } = useSyncStatus()
+ * ```
+ */
+declare function useSyncStatus(): SyncStatusInfo;
+
+/**
+ * The collections an app exposes, read from its `collections` namespace. Purely
+ * structural, so it follows whatever accessor types `createApp` infers from the schema.
+ */
+type AppCollections<TApp> = TApp extends {
+    collections: infer C;
+} ? C : never;
+/** The collection names of an app, as string literals. */
+type AppCollectionName<TApp> = Extract<keyof AppCollections<TApp>, string>;
+/** The record type of a collection accessor, inferred from what its queries return. */
+type AccessorRecord<TAccessor> = TAccessor extends {
+    where(...args: never[]): QueryBuilder<infer R>;
+} ? R : CollectionRecord;
+/** The record type of collection `N` of an app. */
+type AppRecord<TApp, N extends AppCollectionName<TApp>> = AccessorRecord<AppCollections<TApp>[N]>;
+/**
+ * Hooks bound to one app type, returned by {@link createKoraHooks}.
+ */
+interface KoraHooks<TApp> {
+    /** The app from the nearest `<KoraProvider app={app}>`, typed as `TApp`. */
+    useApp: () => TApp;
+    /**
+     * The typed accessor of one collection: `insert`, `update` and `where` are checked
+     * against the schema. The accessor keeps its identity across renders.
+     */
+    useCollection: <N extends AppCollectionName<TApp>>(name: N) => AppCollections<TApp>[N];
+    /** {@link useQuery}: rows are typed from the query builder. */
+    useQuery: typeof useQuery;
+    /** {@link useQueryState}: rows are typed from the query builder. */
+    useQueryState: typeof useQueryState;
+    /** {@link useMutation}. */
+    useMutation: typeof useMutation;
+    /** {@link useSyncStatus}. */
+    useSyncStatus: typeof useSyncStatus;
+}
+/**
+ * Creates React hooks typed for one app, so components get schema-checked
+ * collection names, inserts, updates and rows without passing generics around.
+ * Call it once next to `createApp` and import the hooks from there. Nothing runs at
+ * call time; the hooks read the app from `<KoraProvider app={app}>`.
+ *
+ * @returns {@link KoraHooks} for `TApp`
+ *
+ * @example
+ * ```typescript
+ * // kora.ts
+ * export const app = createApp({ schema })
+ * export const { useCollection, useQuery, useMutation } = createKoraHooks<typeof app>()
+ *
+ * // TodoList.tsx
+ * const todos = useCollection('todos')          // 'todoz' is a type error
+ * const rows = useQuery(todos.where({ completed: false }))
+ * const { mutate: add } = useMutation(todos.insert)
+ * ```
+ */
+declare function createKoraHooks<TApp extends KoraAppLike>(): KoraHooks<TApp>;
+
+/**
+ * React hook that returns a CollectionAccessor for the given collection name.
+ * Convenience hook for accessing a collection without going through the store directly.
+ *
+ * @param name - The collection name (must match a collection in the schema)
+ * @returns CollectionAccessor with insert, findById, update, delete, and where methods
+ *
+ * @example
+ * ```typescript
+ * const todos = useCollection('todos')
+ * await todos.insert({ title: 'New todo' })
+ * ```
+ */
+declare function useCollection(name: string): CollectionAccessor;
+
+interface UseRichTextOptions {
+    user?: AwarenessUser;
+    useDocChannel?: boolean;
+}
+/**
+ * Binds a richtext field to a shared Yjs document for editor integration.
+ */
+declare function useRichText(collectionName: string, recordId: string, fieldName: string, options?: UseRichTextOptions): UseRichTextResult;
+
+/**
+ * Sets the local user's collaborative presence state.
+ *
+ * Automatically cleans up presence on unmount.
+ */
+declare function usePresence(user: {
+    name: string;
+    color: string;
+    avatar?: string;
+} | null): void;
+
+/**
+ * Returns all currently connected collaborators' awareness states.
+ *
+ * Excludes the local user — only returns remote peers. Safe under server rendering
+ * (`renderToString`, Next.js App Router): the server and the hydration pass see `[]`.
+ *
+ * @returns The remote peers' awareness states; the same array until they change
+ */
+declare function useCollaborators(): AwarenessState[];
+
+export { type AccessorRecord, type AppCollectionName, type AppCollections, type AppRecord, type AuthBoundKoraErrorContext, type AuthBoundKoraInitializationError, AuthBoundKoraProvider, type AuthBoundKoraProviderProps, type AuthBoundKoraSession, type KoraAppLike, type KoraContextValue, type KoraHooks, KoraProvider, type KoraProviderProps, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryStateResult, type UseRichTextOptions, type UseRichTextResult, classifyKoraInitializationError, createKoraHooks, useApp, useCollaborators, useCollection, useMutation, usePresence, useQuery, useQueryState, useRichText, useSyncStatus };