@symbiote-native/sqlite 0.1.0

package/build/core/storage.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Update function for `setItemAsync()`/`setItemSync()`. Computes the new value from the
+ * previous one (`null` when the key was unset) and returns the value to store.
+ */
+export type ISQLiteStorageSetItemUpdateFunction = (prevValue: string | null) => string;
+/**
+ * A key-value store backed by SQLite. The constructor's `databaseName` is the database file
+ * name used for storage.
+ */
+export declare class SQLiteStorage {
+    private readonly databaseName;
+    private db;
+    private readonly awaitLock;
+    constructor(databaseName: string);
+    /** Retrieves the value for the given key. */
+    getItemAsync(key: string): Promise<string | null>;
+    /**
+     * Sets the value for the given key. A function computes the new value from the previous one.
+     */
+    setItemAsync(key: string, value: string | ISQLiteStorageSetItemUpdateFunction): Promise<void>;
+    /** Removes the value for the given key. Returns whether a row was actually removed. */
+    removeItemAsync(key: string): Promise<boolean>;
+    /** Retrieves every key stored. */
+    getAllKeysAsync(): Promise<string[]>;
+    /** Clears every key-value pair. Returns whether anything was actually cleared. */
+    clearAsync(): Promise<boolean>;
+    /** Closes the database connection. */
+    closeAsync(): Promise<void>;
+    /** Retrieves the number of key-value pairs stored. */
+    getLengthAsync(): Promise<number>;
+    /** Retrieves the key at the given index. */
+    getKeyByIndexAsync(index: number): Promise<string | null>;
+    /**
+     * Retrieves the value for the given key.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getItemSync(key: string): string | null;
+    /**
+     * Sets the value for the given key. A function computes the new value from the previous one.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    setItemSync(key: string, value: string | ISQLiteStorageSetItemUpdateFunction): void;
+    /**
+     * Removes the value for the given key. Returns whether a row was actually removed.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    removeItemSync(key: string): boolean;
+    /**
+     * Retrieves every key stored.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getAllKeysSync(): string[];
+    /**
+     * Clears every key-value pair. Returns whether anything was actually cleared.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    clearSync(): boolean;
+    /**
+     * Closes the database connection.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    closeSync(): void;
+    /**
+     * Retrieves the number of key-value pairs stored.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getLengthSync(): number;
+    /**
+     * Retrieves the key at the given index.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getKeyByIndexSync(index: number): string | null;
+    /** Alias for `getItemAsync()`. */
+    getItem(key: string): Promise<string | null>;
+    /** Alias for `setItemAsync()`. */
+    setItem(key: string, value: string | ISQLiteStorageSetItemUpdateFunction): Promise<void>;
+    /** Alias for `removeItemAsync()`. */
+    removeItem(key: string): Promise<void>;
+    /** Alias for `getAllKeysAsync()`. */
+    getAllKeys(): Promise<string[]>;
+    /** Alias for `clearAsync()`. */
+    clear(): Promise<void>;
+    /** Merges the given value with the existing value for the key — a deep merge for JSON. */
+    mergeItem(key: string, value: string): Promise<void>;
+    /** Retrieves the values for the given keys. */
+    multiGet(keys: string[]): Promise<[string, string | null][]>;
+    /** Sets multiple key-value pairs. */
+    multiSet(keyValuePairs: [string, string][]): Promise<void>;
+    /** Removes the values for the given keys. */
+    multiRemove(keys: string[]): Promise<void>;
+    /** Merges multiple key-value pairs — a deep merge for JSON existing values. */
+    multiMerge(keyValuePairs: [string, string][]): Promise<void>;
+    /** Alias for `closeAsync()`. */
+    close(): Promise<void>;
+    private getDbAsync;
+    private getDbSync;
+    private maybeMigrateDbAsync;
+    private maybeMigrateDbSync;
+    private checkValidInput;
+}
+/**
+ * A drop-in replacement for `AsyncStorage` from `@react-native-async-storage/async-storage`.
+ */
+export declare const AsyncStorage: SQLiteStorage;
+export default AsyncStorage;
+/** Alias for `AsyncStorage`, given the storage offers more than asynchronous methods. */
+export declare const Storage: SQLiteStorage;

package/build/core/storage.js

@@ -0,0 +1,382 @@
+// Ported from expo-sqlite's Storage.ts (.vendors/expo @ origin/sdk-57,
+// packages/expo-sqlite/src/Storage.ts), renamed with this repo's `I`-prefix convention.
+//
+// Published on its own subpath (`@symbiote-native/sqlite/kv-store`) rather than the package
+// root — see the README for why.
+import AwaitLock from 'await-lock';
+import { openDatabaseAsync, openDatabaseSync } from './sqlite-database.js';
+import { normalizeStorageIndex } from './param-utils.js';
+const DATABASE_VERSION = 1;
+const STATEMENT_GET = 'SELECT value FROM storage WHERE key = ?;';
+const STATEMENT_SET = 'INSERT INTO storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value;';
+const STATEMENT_REMOVE = 'DELETE FROM storage WHERE key = ?;';
+const STATEMENT_GET_ALL_KEYS = 'SELECT key FROM storage;';
+const STATEMENT_CLEAR = 'DELETE FROM storage;';
+const STATEMENT_LENGTH = 'SELECT COUNT(*) as count FROM storage;';
+const STATEMENT_GET_KEY_BY_INDEX = 'SELECT key FROM storage LIMIT 1 OFFSET ?;';
+const MIGRATION_STATEMENT_0 = 'CREATE TABLE IF NOT EXISTS storage (key TEXT PRIMARY KEY NOT NULL, value TEXT);';
+/**
+ * A key-value store backed by SQLite. The constructor's `databaseName` is the database file
+ * name used for storage.
+ */
+export class SQLiteStorage {
+    databaseName;
+    db = null;
+    awaitLock = new AwaitLock();
+    constructor(databaseName) {
+        this.databaseName = databaseName;
+    }
+    //#region Asynchronous API
+    /** Retrieves the value for the given key. */
+    async getItemAsync(key) {
+        this.checkValidInput(key);
+        const db = await this.getDbAsync();
+        const result = await db.getFirstAsync(STATEMENT_GET, key);
+        return result?.value ?? null;
+    }
+    /**
+     * Sets the value for the given key. A function computes the new value from the previous one.
+     */
+    async setItemAsync(key, value) {
+        this.checkValidInput(key, value);
+        const db = await this.getDbAsync();
+        if (typeof value === 'function') {
+            await db.withExclusiveTransactionAsync(async (tx) => {
+                const prevResult = await tx.getFirstAsync(STATEMENT_GET, key);
+                const prevValue = prevResult?.value ?? null;
+                const nextValue = value(prevValue);
+                this.checkValidInput(key, nextValue);
+                await tx.runAsync(STATEMENT_SET, key, nextValue);
+            });
+            return;
+        }
+        await db.runAsync(STATEMENT_SET, key, value);
+    }
+    /** Removes the value for the given key. Returns whether a row was actually removed. */
+    async removeItemAsync(key) {
+        this.checkValidInput(key);
+        const db = await this.getDbAsync();
+        const result = await db.runAsync(STATEMENT_REMOVE, key);
+        return result.changes > 0;
+    }
+    /** Retrieves every key stored. */
+    async getAllKeysAsync() {
+        const db = await this.getDbAsync();
+        const result = await db.getAllAsync(STATEMENT_GET_ALL_KEYS);
+        return result.map(({ key }) => key);
+    }
+    /** Clears every key-value pair. Returns whether anything was actually cleared. */
+    async clearAsync() {
+        const db = await this.getDbAsync();
+        const result = await db.runAsync(STATEMENT_CLEAR);
+        return result.changes > 0;
+    }
+    /** Closes the database connection. */
+    async closeAsync() {
+        await this.awaitLock.acquireAsync();
+        try {
+            if (this.db) {
+                await this.db.closeAsync();
+                this.db = null;
+            }
+        }
+        finally {
+            this.awaitLock.release();
+        }
+    }
+    /** Retrieves the number of key-value pairs stored. */
+    async getLengthAsync() {
+        const db = await this.getDbAsync();
+        const result = await db.getFirstAsync(STATEMENT_LENGTH);
+        return result?.count ?? 0;
+    }
+    /** Retrieves the key at the given index. */
+    async getKeyByIndexAsync(index) {
+        const db = await this.getDbAsync();
+        const offset = normalizeStorageIndex(index);
+        if (offset == null) {
+            return null;
+        }
+        const result = await db.getFirstAsync(STATEMENT_GET_KEY_BY_INDEX, offset);
+        return result?.key ?? null;
+    }
+    //#endregion
+    //#region Synchronous API
+    /**
+     * Retrieves the value for the given key.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getItemSync(key) {
+        this.checkValidInput(key);
+        const db = this.getDbSync();
+        const result = db.getFirstSync(STATEMENT_GET, key);
+        return result?.value ?? null;
+    }
+    /**
+     * Sets the value for the given key. A function computes the new value from the previous one.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    setItemSync(key, value) {
+        this.checkValidInput(key, value);
+        const db = this.getDbSync();
+        if (typeof value === 'function') {
+            db.withTransactionSync(() => {
+                const prevResult = db.getFirstSync(STATEMENT_GET, key);
+                const prevValue = prevResult?.value ?? null;
+                const nextValue = value(prevValue);
+                this.checkValidInput(key, nextValue);
+                db.runSync(STATEMENT_SET, key, nextValue);
+            });
+            return;
+        }
+        db.runSync(STATEMENT_SET, key, value);
+    }
+    /**
+     * Removes the value for the given key. Returns whether a row was actually removed.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    removeItemSync(key) {
+        this.checkValidInput(key);
+        const db = this.getDbSync();
+        const result = db.runSync(STATEMENT_REMOVE, key);
+        return result.changes > 0;
+    }
+    /**
+     * Retrieves every key stored.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getAllKeysSync() {
+        const db = this.getDbSync();
+        const result = db.getAllSync(STATEMENT_GET_ALL_KEYS);
+        return result.map(({ key }) => key);
+    }
+    /**
+     * Clears every key-value pair. Returns whether anything was actually cleared.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    clearSync() {
+        const db = this.getDbSync();
+        const result = db.runSync(STATEMENT_CLEAR);
+        return result.changes > 0;
+    }
+    /**
+     * Closes the database connection.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    closeSync() {
+        if (this.db) {
+            this.db.closeSync();
+            this.db = null;
+        }
+    }
+    /**
+     * Retrieves the number of key-value pairs stored.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getLengthSync() {
+        const db = this.getDbSync();
+        const result = db.getFirstSync(STATEMENT_LENGTH);
+        return result?.count ?? 0;
+    }
+    /**
+     * Retrieves the key at the given index.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getKeyByIndexSync(index) {
+        const db = this.getDbSync();
+        const offset = normalizeStorageIndex(index);
+        if (offset == null) {
+            return null;
+        }
+        const result = db.getFirstSync(STATEMENT_GET_KEY_BY_INDEX, offset);
+        return result?.key ?? null;
+    }
+    //#endregion
+    //#region react-native-async-storage compatible API
+    /** Alias for `getItemAsync()`. */
+    async getItem(key) {
+        return this.getItemAsync(key);
+    }
+    /** Alias for `setItemAsync()`. */
+    async setItem(key, value) {
+        await this.setItemAsync(key, value);
+    }
+    /** Alias for `removeItemAsync()`. */
+    async removeItem(key) {
+        await this.removeItemAsync(key);
+    }
+    /** Alias for `getAllKeysAsync()`. */
+    async getAllKeys() {
+        return this.getAllKeysAsync();
+    }
+    /** Alias for `clearAsync()`. */
+    async clear() {
+        await this.clearAsync();
+    }
+    /** Merges the given value with the existing value for the key — a deep merge for JSON. */
+    async mergeItem(key, value) {
+        this.checkValidInput(key, value);
+        await this.setItemAsync(key, prevValue => {
+            if (prevValue == null) {
+                return value;
+            }
+            const prevJSON = JSON.parse(prevValue);
+            const newJSON = JSON.parse(value);
+            const mergedJSON = mergeDeep(prevJSON, newJSON);
+            return JSON.stringify(mergedJSON);
+        });
+    }
+    /** Retrieves the values for the given keys. */
+    async multiGet(keys) {
+        return Promise.all(keys.map(async (key) => {
+            this.checkValidInput(key);
+            return [key, await this.getItemAsync(key)];
+        }));
+    }
+    /** Sets multiple key-value pairs. */
+    async multiSet(keyValuePairs) {
+        const db = await this.getDbAsync();
+        await db.withExclusiveTransactionAsync(async (tx) => {
+            for (const [key, value] of keyValuePairs) {
+                this.checkValidInput(key, value);
+                await tx.runAsync(STATEMENT_SET, key, value);
+            }
+        });
+    }
+    /** Removes the values for the given keys. */
+    async multiRemove(keys) {
+        const db = await this.getDbAsync();
+        await db.withExclusiveTransactionAsync(async (tx) => {
+            for (const key of keys) {
+                this.checkValidInput(key);
+                await tx.runAsync(STATEMENT_REMOVE, key);
+            }
+        });
+    }
+    /** Merges multiple key-value pairs — a deep merge for JSON existing values. */
+    async multiMerge(keyValuePairs) {
+        const db = await this.getDbAsync();
+        await db.withExclusiveTransactionAsync(async (tx) => {
+            for (const [key, value] of keyValuePairs) {
+                this.checkValidInput(key, value);
+                const prevValue = await tx.getFirstAsync(STATEMENT_GET, key);
+                if (prevValue == null) {
+                    await tx.runAsync(STATEMENT_SET, key, value);
+                    continue;
+                }
+                const prevJSON = JSON.parse(prevValue.value);
+                const newJSON = JSON.parse(value);
+                const mergedJSON = mergeDeep(prevJSON, newJSON);
+                await tx.runAsync(STATEMENT_SET, key, JSON.stringify(mergedJSON));
+            }
+        });
+    }
+    /** Alias for `closeAsync()`. */
+    async close() {
+        await this.closeAsync();
+    }
+    //#endregion
+    //#region Internals
+    async getDbAsync() {
+        await this.awaitLock.acquireAsync();
+        try {
+            if (!this.db) {
+                const db = await openDatabaseAsync(this.databaseName);
+                await this.maybeMigrateDbAsync(db);
+                this.db = db;
+            }
+        }
+        finally {
+            this.awaitLock.release();
+        }
+        return this.db;
+    }
+    getDbSync() {
+        // Unlike getDbAsync(), this cannot take `awaitLock` — it is promise-based and this method is
+        // synchronous. The migration is idempotent instead, so the next open repairs a database a
+        // race left without a `storage` table.
+        if (!this.db) {
+            const db = openDatabaseSync(this.databaseName);
+            this.maybeMigrateDbSync(db);
+            this.db = db;
+        }
+        return this.db;
+    }
+    maybeMigrateDbAsync(db) {
+        return db.withTransactionAsync(async () => {
+            const result = await db.getFirstAsync('PRAGMA user_version');
+            const currentDbVersion = result?.user_version ?? 0;
+            // Baseline schema, deliberately outside the version ladder below — `CREATE TABLE IF NOT
+            // EXISTS` is a no-op on a healthy database and also repairs one a raced first-run
+            // migration left at `user_version >= 1` with no `storage` table. A new column has to be
+            // added here too, so fresh and repaired databases both get it.
+            await db.execAsync(MIGRATION_STATEMENT_0);
+            // Version ladder: add each new migration below, gated on `currentDbVersion`. Since the
+            // baseline above already carries every column, a ladder entry adding one has to tolerate
+            // it already being there — gate it on `PRAGMA table_info(storage)`, or a fresh database
+            // fails the migration with `duplicate column name`.
+            if (currentDbVersion >= DATABASE_VERSION) {
+                return;
+            }
+            await db.execAsync(`PRAGMA user_version = ${DATABASE_VERSION}`);
+        });
+    }
+    maybeMigrateDbSync(db) {
+        db.withTransactionSync(() => {
+            const result = db.getFirstSync('PRAGMA user_version');
+            const currentDbVersion = result?.user_version ?? 0;
+            // Keep in sync with maybeMigrateDbAsync(), which documents the two steps below.
+            db.execSync(MIGRATION_STATEMENT_0);
+            if (currentDbVersion >= DATABASE_VERSION) {
+                return;
+            }
+            db.execSync(`PRAGMA user_version = ${DATABASE_VERSION}`);
+        });
+    }
+    checkValidInput(...input) {
+        const [key, value] = input;
+        if (typeof key !== 'string') {
+            throw new Error(`[SQLiteStorage] Using ${typeof key} type for key is not supported. Use string instead. Key passed: ${String(key)}`);
+        }
+        if (input.length > 1 &&
+            typeof value !== 'string' &&
+            typeof value !== 'function') {
+            throw new Error(`[SQLiteStorage] Using ${typeof value} type for value is not supported. Use string instead. Key passed: ${key}. Value passed : ${String(value)}`);
+        }
+    }
+}
+/** Recursively merges two JSON-decoded values, concatenating arrays and merging objects. */
+function mergeDeep(target, source) {
+    if (typeof target !== 'object' || target === null || Array.isArray(target)) {
+        return source;
+    }
+    if (typeof source !== 'object' || source === null || Array.isArray(source)) {
+        return target;
+    }
+    // I/O edge: both are JSON.parse() output narrowed only to "non-null, non-array object" above —
+    // JSON itself carries no further static shape to check against.
+    const targetRecord = target;
+    const sourceRecord = source;
+    const output = { ...targetRecord };
+    for (const key of Object.keys(sourceRecord)) {
+        const sourceValue = sourceRecord[key];
+        if (Array.isArray(sourceValue)) {
+            const existing = output[key];
+            output[key] = (Array.isArray(existing) ? existing : []).concat(sourceValue);
+        }
+        else if (typeof sourceValue === 'object' && sourceValue !== null) {
+            output[key] = mergeDeep(targetRecord[key], sourceValue);
+        }
+        else {
+            output[key] = sourceValue;
+        }
+    }
+    return output;
+}
+/**
+ * A drop-in replacement for `AsyncStorage` from `@react-native-async-storage/async-storage`.
+ */
+export const AsyncStorage = new SQLiteStorage('ExpoSQLiteStorage');
+export default AsyncStorage;
+/** Alias for `AsyncStorage`, given the storage offers more than asynchronous methods. */
+export const Storage = AsyncStorage;

package/build/core/types.d.ts

@@ -0,0 +1,30 @@
+import type { SQLiteDatabase } from './sqlite-database';
+import type { ISQLiteOpenOptions } from './native-database';
+/** The event payload for `addDatabaseChangeListener`. */
+export type IDatabaseChangeEvent = {
+    /** The database name — `main` by default, or another name set via `ATTACH DATABASE`. */
+    databaseName: string;
+    /** The absolute file path to the database. */
+    databaseFilePath: string;
+    /** The table name. */
+    tableName: string;
+    /** The changed row ID. */
+    rowId: number;
+};
+/**
+ * Called once, right after the native handle opens and before `openDatabaseAsync`/
+ * `openDatabaseSync` returns the database — e.g. to run `execAsync`/`execSync` migrations.
+ *
+ * **Deviation from upstream:** expo-sqlite only exposes this as a `SQLiteProviderProps.onInit`
+ * field, called by its React `<SQLiteProvider>` after opening, before rendering children. This
+ * package has no Provider yet (per-adapter Provider/hook wrappers are a later, separate pass —
+ * see the README), so `onInit` is exposed directly on `openDatabaseAsync`/`openDatabaseSync`
+ * instead, giving any adapter — or plain module-scope code with no view tree at all — the same
+ * "run this once right after open" hook without needing a Provider to exist first. A future
+ * Provider can still accept its own `onInit` prop and either forward it here or call the
+ * callback itself; that choice is left to that later pass.
+ */
+export type IOnInitCallback = (db: SQLiteDatabase) => Promise<void> | void;
+export type IOpenDatabaseOptions = ISQLiteOpenOptions & {
+    onInit?: IOnInitCallback;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export * from './sqlite-context';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export * from './sqlite-context.js';

package/build/react/sqlite-context.d.ts

@@ -0,0 +1,25 @@
+import { type ReactElement, type ReactNode } from 'react';
+import { type IOnInitCallback, type ISQLiteOpenOptions, type SQLiteDatabase } from '../core';
+export type ISQLiteProviderProps = {
+    /** The name of the database file to open. */
+    databaseName: string;
+    /** The directory where the database file is located. @default defaultDatabaseDirectory */
+    directory?: string;
+    /** Open options. */
+    options?: ISQLiteOpenOptions;
+    /** The children to render. */
+    children: ReactNode;
+    /** Run once, right after the native handle opens and before children render. */
+    onInit?: IOnInitCallback;
+    /** Handle errors from SQLiteProvider. @default rethrow the error */
+    onError?: (error: Error) => void;
+    /** Enable React.Suspense integration. @default false */
+    useSuspense?: boolean;
+};
+/**
+ * Context.Provider component that provides a SQLite database to all children. All descendants
+ * of this component can access the database via `useSQLiteContext`.
+ */
+export declare const SQLiteProvider: import("react").MemoExoticComponent<({ children, onError, useSuspense, ...props }: ISQLiteProviderProps) => ReactElement | null>;
+/** A hook for accessing the SQLite database provided by an ancestor `<SQLiteProvider>`. */
+export declare function useSQLiteContext(): SQLiteDatabase;

package/build/react/sqlite-context.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// React <SQLiteProvider> + useSQLiteContext(), ported from expo-sqlite's hooks.tsx (sdk-57,
+// .vendors/expo) onto this package's own openDatabaseAsync/SQLiteDatabase. Deliberately excludes
+// `assetSource` (bundling a database from a require()'d asset needs expo-asset, out of scope for
+// this pass — see the README). React 19's built-in `use()` replaces upstream's private
+// Suspense-promise polyfill (~40 LOC of `ReactUsePromise` plumbing, unnecessary now that the
+// peer range is react >=19.0.0). Unlike upstream, `onInit` is NOT invoked here — this package's
+// own `openDatabaseAsync` already runs it internally before resolving (see
+// `IOnInitCallback`'s doc comment in `core/types.ts`), so the provider only has to forward it.
+import { createContext, memo, use, useContext, useEffect, useRef, useState, } from 'react';
+import { openDatabaseAsync, } from '../core/index.js';
+const SQLiteContext = createContext(null);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Structural equality, recursing into plain objects — used only to keep the memo comparator
+ * below from reopening a database when a parent re-passes a deep-equal but new `options` object. */
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!isRecord(a) || !isRecord(b))
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return (aKeys.length === bKeys.length &&
+        aKeys.every(key => deepEqual(a[key], b[key])));
+}
+function propsAreEqual(prev, next) {
+    return (prev.databaseName === next.databaseName &&
+        deepEqual(prev.options, next.options) &&
+        prev.directory === next.directory &&
+        prev.onInit === next.onInit &&
+        prev.onError === next.onError &&
+        prev.useSuspense === next.useSuspense);
+}
+function toError(caught) {
+    return caught instanceof Error ? caught : new Error(String(caught));
+}
+/**
+ * Context.Provider component that provides a SQLite database to all children. All descendants
+ * of this component can access the database via `useSQLiteContext`.
+ */
+export const SQLiteProvider = memo(function SQLiteProvider({ children, onError, useSuspense = false, ...props }) {
+    if (onError != null && useSuspense) {
+        throw new Error('Cannot use `onError` with `useSuspense`, use error boundaries instead.');
+    }
+    if (useSuspense) {
+        return (_jsx(SQLiteProviderSuspense, { ...props, children: children }));
+    }
+    return (_jsx(SQLiteProviderNonSuspense, { ...props, onError: onError, children: children }));
+}, propsAreEqual);
+/** A hook for accessing the SQLite database provided by an ancestor `<SQLiteProvider>`. */
+export function useSQLiteContext() {
+    const context = useContext(SQLiteContext);
+    if (context == null) {
+        throw new Error('useSQLiteContext must be used within a <SQLiteProvider>');
+    }
+    return context;
+}
+//#region Internals
+function SQLiteProviderNonSuspense({ databaseName, directory, options, children, onInit, onError, }) {
+    const databaseRef = useRef(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        async function setup() {
+            try {
+                const db = await openDatabaseAsync(databaseName, { ...options, onInit }, directory);
+                databaseRef.current = db;
+                setLoading(false);
+            }
+            catch (caught) {
+                setError(toError(caught));
+            }
+        }
+        async function teardown(db) {
+            try {
+                await db?.closeAsync();
+            }
+            catch (caught) {
+                setError(toError(caught));
+            }
+        }
+        setup();
+        return () => {
+            const db = databaseRef.current;
+            teardown(db);
+            databaseRef.current = null;
+            setLoading(true);
+        };
+    }, [databaseName, directory, options, onInit]);
+    if (error != null) {
+        const handler = onError ??
+            ((caught) => {
+                throw caught;
+            });
+        handler(error);
+    }
+    if (loading || databaseRef.current == null) {
+        return null;
+    }
+    return (_jsx(SQLiteContext.Provider, { value: databaseRef.current, children: children }));
+}
+// A single module-scope cache entry, mirroring upstream: only ONE suspended database is tracked
+// across the whole app at a time, and a second concurrent <SQLiteProvider useSuspense> for a
+// different database closes the first before opening the next. Faithful to upstream's own
+// `databaseInstance` shape, not a per-provider cache.
+let databaseCache = null;
+function getDatabaseAsync(databaseName, directory, options, onInit) {
+    if (databaseCache != null &&
+        databaseCache.databaseName === databaseName &&
+        databaseCache.directory === directory &&
+        databaseCache.options === options &&
+        databaseCache.onInit === onInit) {
+        return databaseCache.promise;
+    }
+    const previous = databaseCache;
+    const promise = previous != null
+        ? previous.promise
+            .then(db => db.closeAsync())
+            .then(() => openDatabaseAsync(databaseName, { ...options, onInit }, directory))
+        : openDatabaseAsync(databaseName, { ...options, onInit }, directory);
+    databaseCache = { databaseName, directory, options, onInit, promise };
+    return promise;
+}
+function SQLiteProviderSuspense({ databaseName, directory, options, children, onInit, }) {
+    const database = use(getDatabaseAsync(databaseName, directory, options, onInit));
+    return (_jsx(SQLiteContext.Provider, { value: database, children: children }));
+}