@symbiote-native/sqlite 0.1.0

package/build/solid/index.d.ts

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

package/build/solid/index.js

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

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

@@ -0,0 +1,23 @@
+import { type JSX } from 'solid-js';
+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: JSX.Element;
+    /** Run once, right after the native handle opens and before children render. */
+    onInit?: IOnInitCallback;
+    /** Handle errors from SQLiteProvider. @default rethrow (propagate through Solid's error context) */
+    onError?: (error: Error) => void;
+};
+/**
+ * Context.Provider component that provides a SQLite database to all children. All descendants
+ * of this component can access the database via `useSQLiteContext`.
+ */
+export declare function SQLiteProvider(props: ISQLiteProviderProps): JSX.Element;
+/** A primitive for accessing the SQLite database provided by an ancestor `<SQLiteProvider>`. */
+export declare function useSQLiteContext(): SQLiteDatabase;

package/build/solid/sqlite-context.js

@@ -0,0 +1,106 @@
+// Solid <SQLiteProvider> + useSQLiteContext(), ported from expo-sqlite's hooks.tsx (sdk-57,
+// .vendors/expo) onto this package's own openDatabaseAsync/SQLiteDatabase — see ../react's
+// sqlite-context.tsx for the React twin this mirrors the OBSERVABLE contract of (the React-only
+// mechanics, useEffect/use()/Suspense, don't transfer).
+//
+// Plain `.ts`, no JSX: this package's tsconfig has no per-directory override and inherits the
+// root `jsx: "react-jsx"` (set for the React entry), so a `.tsx` file here would type-check its
+// JSX against React's JSX namespace, not Solid's — the same trap `solid-jsx-namespace.md`
+// documents for the adapter itself. `createComponent` is called directly instead, exactly as
+// `packages/navigation/src/solid/stack/index.ts` does throughout.
+//
+// createResource is the right tool: it natively models pending/error/ready, and — the load-bearing
+// part — reading an ERRORED resource accessor THROWS SYNCHRONOUSLY on every read (solid-js's own
+// `read()`: `if (err !== undefined && !pr) throw err`), tracked or not. That is Solid's real
+// equivalent of upstream's `handler = (e) => { throw e }` default: no onError -> the throw surfaces
+// wherever `db()` is read (here, inside <Show>'s own tracking), and propagates through Solid's
+// error-context chain exactly like any other component/memo/effect throw in this adapter
+// (adapters/solid/src/render.ts's `catchError` + rethrow at the mount root — the tested,
+// established "unhandled async failure" convention for this Solid adapter). With onError present,
+// the fetcher calls it and resolves to `undefined` instead of throwing, so <Show> simply renders
+// nothing rather than propagating — matching upstream's "loading || !db -> render null" forever.
+//
+// Closing the previous database before opening the next reuses createResource's own
+// ResourceFetcherInfo.value (the last successfully resolved value) rather than a second piece of
+// state — it IS "the database this resource had opened before". `openedDb` is a plain closure
+// variable (not read through the resource accessor) so `onCleanup` never has to read a possibly
+// -errored resource, which would itself throw during teardown.
+//
+// assetSource is deliberately NOT ported: it needs expo-asset, out of scope (see the README).
+// useSuspense is deliberately NOT offered: Solid's own <Suspense> already composes with a plain
+// createResource-backed component with zero extra code (any ancestor <Suspense> defers on this
+// resource for free), so there is no second, opt-in code path to build the way React needs one —
+// <prop_types_split_agnostic_vs_per_adapter>'s "framework-idiom divergence" class of omission.
+import { createComponent, createContext, createResource, onCleanup, useContext, } from 'solid-js';
+import { Show } from 'solid-js';
+import { openDatabaseAsync, } from '../core/index.js';
+const SQLiteContext = createContext();
+function toError(cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+}
+/**
+ * Context.Provider component that provides a SQLite database to all children. All descendants
+ * of this component can access the database via `useSQLiteContext`.
+ */
+export function SQLiteProvider(props) {
+    // The last database THIS provider successfully opened — read only by onCleanup, never through
+    // the resource accessor (which throws when the resource is in its errored state).
+    let openedDb;
+    const [db] = createResource(() => ({
+        databaseName: props.databaseName,
+        directory: props.directory,
+        options: props.options,
+        onInit: props.onInit,
+    }), async (source, info) => {
+        if (info.value !== undefined) {
+            await info.value.closeAsync();
+        }
+        try {
+            const opened = await openDatabaseAsync(source.databaseName, { ...source.options, onInit: source.onInit }, source.directory);
+            openedDb = opened;
+            return opened;
+        }
+        catch (cause) {
+            openedDb = undefined;
+            const error = toError(cause);
+            if (props.onError !== undefined) {
+                props.onError(error);
+                return undefined;
+            }
+            throw error;
+        }
+    });
+    onCleanup(() => {
+        void openedDb?.closeAsync();
+    });
+    function renderReady(database) {
+        return createComponent(SQLiteContext.Provider, {
+            get value() {
+                return database();
+            },
+            get children() {
+                return props.children;
+            },
+        });
+    }
+    // A direct call, not createComponent(Show, …): Show is overloaded (keyed vs non-keyed), and
+    // TypeScript resolves an overloaded value against createComponent's generic Component<T> by its
+    // LAST signature only — reporting the non-keyed props object as missing `keyed: true`. Calling
+    // it directly goes through normal overload resolution instead, which picks correctly. Show's own
+    // body needs no extra untrack wrapping (it already wraps every read in its own createMemo), so
+    // nothing behavioral is lost by skipping createComponent here.
+    return Show({
+        get when() {
+            return db();
+        },
+        children: renderReady,
+    });
+}
+/** A primitive for accessing the SQLite database provided by an ancestor `<SQLiteProvider>`. */
+export function useSQLiteContext() {
+    const context = useContext(SQLiteContext);
+    if (context === undefined) {
+        throw new Error('useSQLiteContext must be used within a <SQLiteProvider>');
+    }
+    return context;
+}

package/build/svelte/SQLiteProvider.svelte

@@ -0,0 +1,88 @@
+<script lang="ts">
+  // SQLiteProvider: the Svelte equivalent of upstream expo-sqlite's SQLiteProvider/
+  // useSQLiteContext pair (.vendors/expo packages/expo-sqlite/src/hooks.tsx, sdk-57). Opens the
+  // database in an `$effect` (re-running whenever databaseName/directory/options/onInit change —
+  // $effect's own cleanup-then-rerun IS upstream's teardown()-then-setup() dance), renders
+  // nothing until it resolves, and hands the resolved `SQLiteDatabase` to descendants via
+  // `useSQLiteContext` (./sqlite-context).
+  //
+  // Context is provided through a BOXED GETTER set synchronously during init, mirroring
+  // navigation-context.ts: setContext only works at component-init time, but the database
+  // resolves later, so the getter is handed out immediately and its underlying `$state` is
+  // written once the effect settles.
+  //
+  // Deliberately excludes `assetSource` (needs `expo-asset`, out of scope for this package — see
+  // the core layer's own IOnInitCallback doc comment) and `useSuspense` (Svelte has no built-in
+  // Suspense primitive).
+  //
+  // Unlike upstream, `onInit` is not called from here — this package's own `openDatabaseAsync`
+  // already runs it internally before resolving (see `IOnInitCallback`'s doc comment in
+  // `core/types.ts`), so this component only forwards it through `options`.
+  import type { Snippet } from 'svelte';
+  import { openDatabaseAsync } from '../core';
+  import type { IOnInitCallback, ISQLiteOpenOptions, SQLiteDatabase } from '../core';
+  import { setSQLiteContext } from './sqlite-context';
+
+  let {
+    databaseName,
+    directory,
+    options,
+    onInit,
+    onError,
+    children,
+  }: {
+    databaseName: string;
+    directory?: string;
+    options?: ISQLiteOpenOptions;
+    onInit?: IOnInitCallback;
+    onError?: (error: Error) => void;
+    children?: Snippet;
+  } = $props();
+
+  let db = $state<SQLiteDatabase | undefined>(undefined);
+
+  setSQLiteContext({
+    get current(): SQLiteDatabase | undefined {
+      return db;
+    },
+  });
+
+  $effect(() => {
+    const name = databaseName;
+    const dir = directory;
+    const openOptions = options;
+    const init = onInit;
+
+    let cancelled = false;
+    let opened: SQLiteDatabase | undefined;
+
+    openDatabaseAsync(name, { ...openOptions, onInit: init }, dir)
+      .then(database => {
+        if (cancelled) {
+          void database.closeAsync();
+          return;
+        }
+        opened = database;
+        db = database;
+      })
+      .catch((error: unknown) => {
+        if (cancelled) return;
+        const err = error instanceof Error ? error : new Error(String(error));
+        // Upstream default: rethrow. Svelte has no error-boundary equivalent to catch a
+        // synchronous throw from here, so "rethrow" surfaces as an unhandled rejection — the
+        // same observable failure (an uncaught error) upstream produces without `onError`.
+        if (onError) onError(err);
+        else throw err;
+      });
+
+    return () => {
+      cancelled = true;
+      db = undefined;
+      if (opened) void opened.closeAsync();
+    };
+  });
+</script>
+
+{#if db}
+  {@render children?.()}
+{/if}

package/build/svelte/SQLiteProvider.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { IOnInitCallback, ISQLiteOpenOptions } from '../core';
+type $$ComponentProps = {
+    databaseName: string;
+    directory?: string;
+    options?: ISQLiteOpenOptions;
+    onInit?: IOnInitCallback;
+    onError?: (error: Error) => void;
+    children?: Snippet;
+};
+declare const SQLiteProvider: import("svelte").Component<$$ComponentProps, {}, "">;
+type SQLiteProvider = ReturnType<typeof SQLiteProvider>;
+export default SQLiteProvider;

package/build/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { default as SQLiteProvider } from './SQLiteProvider.svelte';
+export * from './sqlite-context';

package/build/svelte/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/sqlite/svelte: SQLiteProvider + useSQLiteContext over the framework-agnostic
+// core. Mirrors packages/navigation/src/svelte/index.ts's barrel shape for a `.svelte` component.
+export * from '../core/index.js';
+export { default as SQLiteProvider } from './SQLiteProvider.svelte';
+export * from './sqlite-context.js';

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

@@ -0,0 +1,11 @@
+import type { SQLiteDatabase } from '../core';
+export type ISQLiteContextValue = {
+    readonly current: SQLiteDatabase | undefined;
+};
+export declare function setSQLiteContext(value: ISQLiteContextValue): void;
+/**
+ * A global function for accessing the SQLite database provided by the nearest ancestor
+ * `<SQLiteProvider>`. Throws if called outside one — matching upstream expo-sqlite's
+ * `useSQLiteContext` (`.vendors/expo` packages/expo-sqlite/src/hooks.tsx, sdk-57).
+ */
+export declare function useSQLiteContext(): SQLiteDatabase;

package/build/svelte/sqlite-context.js

@@ -0,0 +1,23 @@
+// Svelte context accessor for the database `<SQLiteProvider>` opens. Mirrors
+// packages/navigation/src/svelte/navigation-context.ts's boxed-getter shape: Svelte's
+// setContext only runs synchronously during component init, while the database resolves later
+// (an async openDatabaseAsync), so the provider hands out a getter object up front and mutates
+// the value it reads later instead of calling setContext once resolution finishes.
+import { getContext, setContext } from 'svelte';
+const SQLITE_CONTEXT_KEY = Symbol('symbiote-sqlite-context');
+// Written only from <SQLiteProvider>'s own init, never by app code.
+export function setSQLiteContext(value) {
+    setContext(SQLITE_CONTEXT_KEY, value);
+}
+/**
+ * A global function for accessing the SQLite database provided by the nearest ancestor
+ * `<SQLiteProvider>`. Throws if called outside one — matching upstream expo-sqlite's
+ * `useSQLiteContext` (`.vendors/expo` packages/expo-sqlite/src/hooks.tsx, sdk-57).
+ */
+export function useSQLiteContext() {
+    const value = getContext(SQLITE_CONTEXT_KEY);
+    if (value === undefined || value.current === undefined) {
+        throw new Error('useSQLiteContext must be used within a <SQLiteProvider>');
+    }
+    return value.current;
+}

package/build/vue/index.d.ts

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

package/build/vue/index.js

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

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

@@ -0,0 +1,21 @@
+import type { ISQLiteOpenOptions, SQLiteDatabase } from '../core';
+export type ISQLiteProviderProps = {
+    databaseName: string;
+    directory?: string;
+    options?: ISQLiteOpenOptions;
+    onInit?: (db: SQLiteDatabase) => Promise<void> | void;
+    onError?: (error: Error) => void;
+};
+/**
+ * Opens `databaseName` (re-opening whenever `databaseName`/`directory`/`options`/`onInit`
+ * change) and provides the resulting `SQLiteDatabase` to its default-slot children via
+ * `useSQLiteContext`. Renders nothing while opening or on failure with no `onError`; on failure
+ * with `onError`, calls it and renders nothing. Closes the database before re-opening and on
+ * unmount.
+ */
+export declare const SQLiteProvider: import("@vue/runtime-core").DefineSetupFnComponent<ISQLiteProviderProps, {}, {}, ISQLiteProviderProps & {}, import("@vue/runtime-core").PublicProps>;
+/**
+ * Reads the `SQLiteDatabase` opened by the nearest ancestor `<SQLiteProvider>`. Throws when
+ * called outside one.
+ */
+export declare function useSQLiteContext(): SQLiteDatabase;

package/build/vue/sqlite-context.js

@@ -0,0 +1,69 @@
+// Vue twin of upstream's `SQLiteProvider`/`useSQLiteContext`
+// (.vendors/expo @ origin/sdk-57, packages/expo-sqlite/src/hooks.tsx). React's mechanics
+// (useEffect/React.use/Suspense) don't transfer; this reproduces the OBSERVABLE contract with
+// Vue's own provide/inject, following packages/navigation/src/vue/navigation-context.ts's shape
+// (a symbol-keyed InjectionKey, a `require*` getter that throws with a hook-scoped message).
+//
+// Deliberately excluded, mirroring core's own `IOpenDatabaseOptions` (see core/types.ts):
+// `assetSource` — needs `expo-asset`, out of scope for this package.
+// Deliberately excluded, this pass only: Suspense integration (`useSuspense`). Vue has its own
+// `<Suspense>` + async `setup()` idiom instead of React's `use()`; wiring this Provider into it is
+// a separate, later decision, not a straight port of React's `useSuspense` flag.
+import { defineComponent, inject, onUnmounted, provide, shallowRef, watch, } from '@vue/runtime-core';
+import { openDatabaseAsync } from '../core/index.js';
+const SQLITE_CONTEXT_KEY = Symbol('sqlite-context');
+function toError(reason) {
+    return reason instanceof Error ? reason : new Error(String(reason));
+}
+/**
+ * Opens `databaseName` (re-opening whenever `databaseName`/`directory`/`options`/`onInit`
+ * change) and provides the resulting `SQLiteDatabase` to its default-slot children via
+ * `useSQLiteContext`. Renders nothing while opening or on failure with no `onError`; on failure
+ * with `onError`, calls it and renders nothing. Closes the database before re-opening and on
+ * unmount.
+ */
+export const SQLiteProvider = defineComponent((props, { slots }) => {
+    const database = shallowRef(null);
+    provide(SQLITE_CONTEXT_KEY, database);
+    // Async watch callback: Vue's `callWithAsyncErrorHandling` attaches a `.catch` to the
+    // returned promise and routes a rejection through `app.config.errorHandler`
+    // (`handleError`) — the same channel `mount()` wires to the engine's shared reporter (see
+    // packages/navigation's composables.test.ts). So a thrown `Error` here IS the Vue-idiomatic
+    // "rethrow", not a swallowed unhandled rejection.
+    watch(() => [props.databaseName, props.directory, props.options, props.onInit], async () => {
+        const previous = database.value;
+        database.value = null;
+        await previous?.closeAsync();
+        const { databaseName, directory, options, onInit, onError } = props;
+        try {
+            database.value = await openDatabaseAsync(databaseName, { ...options, onInit }, directory);
+        }
+        catch (reason) {
+            const error = toError(reason);
+            if (onError !== undefined) {
+                onError(error);
+            }
+            else {
+                throw error;
+            }
+        }
+    }, { immediate: true });
+    onUnmounted(() => {
+        void database.value?.closeAsync();
+    });
+    return () => (database.value !== null ? slots.default?.() : null);
+}, {
+    name: 'SQLiteProvider',
+    props: ['databaseName', 'directory', 'options', 'onInit', 'onError'],
+});
+/**
+ * Reads the `SQLiteDatabase` opened by the nearest ancestor `<SQLiteProvider>`. Throws when
+ * called outside one.
+ */
+export function useSQLiteContext() {
+    const context = inject(SQLITE_CONTEXT_KEY, undefined);
+    if (context === undefined || context.value === null) {
+        throw new Error('useSQLiteContext must be used within a <SQLiteProvider>');
+    }
+    return context.value;
+}

package/build-ngc/angular/index.d.ts

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

package/build-ngc/angular/index.js

@@ -0,0 +1,3 @@
+export * from '../core';
+export * from './sqlite.service';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/build-ngc/angular/sqlite.service.d.ts

@@ -0,0 +1,44 @@
+import { InjectionToken, type OnDestroy, type Provider } from '@angular/core';
+import type { IOpenDatabaseOptions } from '../core';
+import * as i0 from "@angular/core";
+export interface ISqliteConfig {
+    /** The name of the database file to open. */
+    databaseName: string;
+    /** The directory the database file is located in. Defaults to `defaultDatabaseDirectory`. */
+    directory?: string;
+    /** Open options — `onInit` runs once, right after the native handle opens. */
+    options?: IOpenDatabaseOptions;
+    /**
+     * Called instead of the failure sitting quietly in `SqliteService#error` — mirrors upstream's
+     * `SQLiteProviderProps.onError`. Omit it to read the failure off `error()` instead.
+     */
+    onError?: (error: Error) => void;
+}
+export declare const SQLITE_CONFIG: InjectionToken<ISqliteConfig>;
+/**
+ * Declarative config for `SqliteService`'s app-wide database — pass to `bootstrapApplication`'s
+ * (or any environment injector's) `providers`, mirroring mounting `<SQLiteProvider>` once near
+ * the app root.
+ */
+export declare function provideSqliteDatabase(config: ISqliteConfig): Provider;
+export declare class SqliteService implements OnDestroy {
+    private readonly config;
+    private readonly onErrorHandler;
+    private readonly dbResource;
+    /**
+     * The resolved database, or `undefined` before `open()` has resolved. `resource()`'s own
+     * contract: reading this while `error()` is set RE-THROWS that error instead of returning —
+     * this IS the "propagates" half of upstream's `onError` contract for a caller that reads it
+     * directly (e.g. from a template's `@if (sqlite.database(); as db)`).
+     */
+    readonly database: import("@angular/core").WritableSignal<import(".").SQLiteDatabase | undefined>;
+    /** The open failure, if any — reading `error()` itself never throws, only `database()` does. */
+    readonly error: import("@angular/core").Signal<Error | undefined>;
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    constructor();
+    /** Opens (or re-opens, for a new config) the app-wide database. */
+    open(config: ISqliteConfig): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SqliteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SqliteService>;
+}

package/build-ngc/angular/sqlite.service.js

@@ -0,0 +1,85 @@
+// Angular's DI twin of upstream's `<SQLiteProvider>`/`useSQLiteContext`
+// (.vendors/expo@sdk-57 packages/expo-sqlite/src/hooks.tsx): ONE database instance app-wide by
+// default, opened once and read through DI instead of a React context.
+//
+// Declarative config goes through `provideSqliteDatabase()` — the
+// `providers: [{ provide: TOKEN, useValue }]` pattern this repo already uses for
+// gate-demand.ts's `provideGateDemand()` — rather than a scoping directive like navigation's
+// `symbioteNavigationScope`. That directive pattern deliberately mints a FRESH service instance
+// per usage (one per route); wrong here, since a database is a singleton to open once, not
+// something to re-scope per screen.
+//
+// Async state rides Angular's own `resource()` (adapters/angular/src/render/index.ts already
+// leans on it for TransferState) rather than a hand-rolled Promise/Observable — it is the
+// signals-first primitive this Angular adapter already uses for "async value + error + loading",
+// so `database`/`error`/`isLoading` come straight off it instead of a second, parallel state
+// machine. Its own contract already matches upstream's non-Suspense provider: a failure PARKS in
+// `error()` rather than throwing, exactly like `SQLiteProviderNonSuspense`'s `onError` branch
+// parks it in React state instead of re-throwing.
+//
+// Deliberately excluded, same as `../core`: `assetSource` (needs `expo-asset`, out of scope).
+// No Suspense equivalent — Angular has none.
+import { Injectable, InjectionToken, effect, inject, resource, signal, } from '@angular/core';
+import { openDatabaseAsync } from '../core';
+import * as i0 from "@angular/core";
+export const SQLITE_CONFIG = new InjectionToken('symbiote.sqlite-config');
+/**
+ * Declarative config for `SqliteService`'s app-wide database — pass to `bootstrapApplication`'s
+ * (or any environment injector's) `providers`, mirroring mounting `<SQLiteProvider>` once near
+ * the app root.
+ */
+export function provideSqliteDatabase(config) {
+    return { provide: SQLITE_CONFIG, useValue: config };
+}
+export class SqliteService {
+    config = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "config" }] : /* istanbul ignore next */ []));
+    onErrorHandler = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "onErrorHandler" }] : /* istanbul ignore next */ []));
+    dbResource = resource({ ...(ngDevMode ? { debugName: "dbResource" } : /* istanbul ignore next */ {}), params: () => this.config(),
+        loader: ({ params }) => openDatabaseAsync(params.databaseName, params.options, params.directory) });
+    /**
+     * The resolved database, or `undefined` before `open()` has resolved. `resource()`'s own
+     * contract: reading this while `error()` is set RE-THROWS that error instead of returning —
+     * this IS the "propagates" half of upstream's `onError` contract for a caller that reads it
+     * directly (e.g. from a template's `@if (sqlite.database(); as db)`).
+     */
+    database = this.dbResource.value;
+    /** The open failure, if any — reading `error()` itself never throws, only `database()` does. */
+    error = this.dbResource.error;
+    isLoading = this.dbResource.isLoading;
+    constructor() {
+        const injected = inject(SQLITE_CONFIG, { optional: true });
+        if (injected)
+            this.open(injected);
+        effect(() => {
+            const raw = this.dbResource.error();
+            if (raw === undefined)
+                return;
+            const error = raw instanceof Error ? raw : new Error(String(raw));
+            this.onErrorHandler()?.(error);
+        });
+    }
+    /** Opens (or re-opens, for a new config) the app-wide database. */
+    open(config) {
+        this.onErrorHandler.set(config.onError);
+        this.config.set(config);
+    }
+    // ponytail: closes only the CURRENTLY resolved handle, on the service's own teardown
+    // (providedIn: 'root' → root injector destruction). Re-opening with a different config does
+    // not close the previous handle first, unlike upstream's `getDatabaseAsync` memo — add that if
+    // an app actually calls `open()` more than once per lifetime.
+    ngOnDestroy() {
+        // `hasValue()` never throws, unlike reading `.value()` directly on an errored resource.
+        if (!this.dbResource.hasValue())
+            return;
+        void this.dbResource.value().closeAsync();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SqliteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SqliteService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SqliteService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=sqlite.service.js.map

package/build-ngc/angular/sqlite.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.service.js","sourceRoot":"","sources":["../../src/angular/sqlite.service.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,+FAA+F;AAC/F,uEAAuE;AACvE,EAAE;AACF,kEAAkE;AAClE,iFAAiF;AACjF,6FAA6F;AAC7F,gGAAgG;AAChG,2FAA2F;AAC3F,oCAAoC;AACpC,EAAE;AACF,6FAA6F;AAC7F,0FAA0F;AAC1F,iGAAiG;AACjG,6FAA6F;AAC7F,iGAAiG;AACjG,8FAA8F;AAC9F,kDAAkD;AAClD,EAAE;AACF,8FAA8F;AAC9F,6CAA6C;AAE7C,OAAO,EACL,UAAU,EACV,cAAc,EACd,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,GAGP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;;AAiB5C,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAC7C,wBAAwB,CACzB,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAqB;IACzD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AACtD,CAAC;AAGD,MAAM,OAAO,aAAa;IACP,MAAM,GAAG,MAAM,CAA4B,SAAS;+EAAC,CAAC;IACtD,cAAc,GAAG,MAAM,CAEtC,SAAS;uFAAC,CAAC;IAEI,UAAU,GAAG,QAAQ,iFACpC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE;QAC3B,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CACrB,iBAAiB,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,GAC1E,CAAC;IAEH;;;;;OAKG;IACM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;IAC1C,gGAAgG;IACvF,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;IAC9B,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;IAE/C;QACE,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3D,IAAI,QAAQ;YAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAElC,MAAM,CAAC,GAAG,EAAE;YACV,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACpC,IAAI,GAAG,KAAK,SAAS;gBAAE,OAAO;YAC9B,MAAM,KAAK,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,mEAAmE;IACnE,IAAI,CAAC,MAAqB;QACxB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,qFAAqF;IACrF,4FAA4F;IAC5F,+FAA+F;IAC/F,8DAA8D;IAC9D,WAAW;QACT,wFAAwF;QACxF,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;YAAE,OAAO;QACxC,KAAK,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,CAAC;IAC5C,CAAC;uGAjDU,aAAa;2GAAb,aAAa,cADA,MAAM;;2FACnB,aAAa;kBADzB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,10 @@
+export { SQLiteDatabase, defaultDatabaseDirectory, bundledExtensions, openDatabaseAsync, openDatabaseSync, deserializeDatabaseAsync, deserializeDatabaseSync, deleteDatabaseAsync, deleteDatabaseSync, backupDatabaseAsync, backupDatabaseSync, addDatabaseChangeListener, } from './sqlite-database';
+export type { ISQLiteOpenOptions, IDatabaseChangeEvent, IOnInitCallback, IOpenDatabaseOptions, } from './sqlite-database';
+export { SQLiteStatement } from './sqlite-statement';
+export type { ISQLiteBindParams, ISQLiteBindValue, ISQLiteExecuteAsyncResult, ISQLiteExecuteSyncResult, ISQLiteRunResult, ISQLiteVariadicBindParams, } from './sqlite-statement';
+export { SQLiteSession } from './sqlite-session';
+export type { IChangeset } from './sqlite-session';
+export { SQLiteTaggedQuery } from './sqlite-tagged-query';
+export { parseSQLQuery } from './query-utils';
+export type { ISQLParsedInfo } from './query-utils';
+export { createDatabasePath, basename } from './path-utils';

package/build-ngc/core/index.js

@@ -0,0 +1,7 @@
+export { SQLiteDatabase, defaultDatabaseDirectory, bundledExtensions, openDatabaseAsync, openDatabaseSync, deserializeDatabaseAsync, deserializeDatabaseSync, deleteDatabaseAsync, deleteDatabaseSync, backupDatabaseAsync, backupDatabaseSync, addDatabaseChangeListener, } from './sqlite-database';
+export { SQLiteStatement } from './sqlite-statement';
+export { SQLiteSession } from './sqlite-session';
+export { SQLiteTaggedQuery } from './sqlite-tagged-query';
+export { parseSQLQuery } from './query-utils';
+export { createDatabasePath, basename } from './path-utils';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAUrD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/build-ngc/core/native-database.d.ts

@@ -0,0 +1,65 @@
+import type { NativeSession } from './native-session';
+import type { NativeStatement } from './native-statement';
+/** An instance of the native SQLite database handle. */
+export declare class NativeDatabase {
+    constructor(databasePath: string, options?: ISQLiteOpenOptions, serializedData?: Uint8Array);
+    initAsync(): Promise<void>;
+    isInTransactionAsync(): Promise<boolean>;
+    closeAsync(): Promise<void>;
+    execAsync(source: string): Promise<void>;
+    serializeAsync(databaseName: string): Promise<Uint8Array>;
+    prepareAsync(nativeStatement: NativeStatement, source: string): Promise<NativeStatement>;
+    createSessionAsync(nativeSession: NativeSession, dbName: string): Promise<NativeSession>;
+    loadExtensionAsync(libPath: string, entryPoint?: string): Promise<void>;
+    initSync(): void;
+    isInTransactionSync(): boolean;
+    closeSync(): void;
+    execSync(source: string): void;
+    serializeSync(databaseName: string): Uint8Array;
+    prepareSync(nativeStatement: NativeStatement, source: string): NativeStatement;
+    createSessionSync(nativeSession: NativeSession, dbName: string): NativeSession;
+    loadExtensionSync(libPath: string, entryPoint?: string): void;
+    /** Only available when the native module was built against a libSQL-backed SQLite. */
+    syncLibSQL(): Promise<void>;
+}
+/** Options for opening a database. */
+export type ISQLiteOpenOptions = {
+    /**
+     * Whether to call the [`sqlite3_update_hook()`](https://www.sqlite.org/c3ref/update_hook.html)
+     * function and enable `onDatabaseChange` events.
+     * @default false
+     */
+    enableChangeListener?: boolean;
+    /**
+     * Whether to create a new connection even if a connection with the same database name exists
+     * in cache.
+     * @default false
+     */
+    useNewConnection?: boolean;
+    /**
+     * Finalize unclosed statements automatically when the database is closed.
+     * @default true
+     * @hidden
+     */
+    finalizeUnusedStatementsBeforeClosing?: boolean;
+    /** Options for libSQL integration. */
+    libSQLOptions?: {
+        /** The URL of the libSQL server. */
+        url: string;
+        /** The auth token for the libSQL server. */
+        authToken: string;
+        /**
+         * Whether to use remote-only without syncing to a local database.
+         * @default false
+         */
+        remoteOnly?: boolean;
+    };
+};
+type IFlattenedOpenOptions = Omit<ISQLiteOpenOptions, 'libSQLOptions'> & {
+    libSQLUrl?: string;
+    libSQLAuthToken?: string;
+    libSQLRemoteOnly?: boolean;
+};
+/** Flattens `ISQLiteOpenOptions` into the shape the native module expects. */
+export declare function flattenOpenOptions(options: ISQLiteOpenOptions): IFlattenedOpenOptions;
+export {};