hyperdb-wasm 0.0.26268-dev.remotes-origin-wasm.gcf8d815a

package/dist/api.d.ts

@@ -0,0 +1,61 @@
+import { DataType, Table } from 'apache-arrow';
+import type { AsyncRecordBatchStreamReader, TypeMap } from 'apache-arrow';
+import type { HyperDBEngineClient } from './client.js';
+import type { BrowserClientOptions } from './browser.js';
+import type { WasmResult } from './protocol.js';
+export interface HyperDBClient {
+    ready(): Promise<void>;
+    connect(): Promise<WasmResult>;
+    disconnect(connection: number): Promise<WasmResult>;
+    startQuery(connection: number, sql: string): Promise<WasmResult>;
+    insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
+    createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
+    removeFile(path: string): Promise<WasmResult>;
+    pollQuery(query: number): Promise<WasmResult>;
+    cancelQuery(query: number): Promise<WasmResult>;
+    releaseQuery(query: number): Promise<WasmResult>;
+    terminate(): Promise<void>;
+}
+export interface ArrowInsertOptions {
+    readonly name: string;
+    readonly schema?: string;
+    readonly create?: boolean;
+}
+export declare class HyperDB {
+    private readonly client;
+    private terminated;
+    private termination;
+    private readonly connections;
+    constructor(client: HyperDBClient);
+    static create(options?: BrowserClientOptions): Promise<HyperDB>;
+    ready(): Promise<void>;
+    connect(): Promise<HyperDBConnection>;
+    terminate(): Promise<void>;
+    private ensureRunning;
+}
+export declare class HyperDBConnection {
+    private readonly client;
+    private readonly connection;
+    private readonly onClose;
+    private closed;
+    private active;
+    private closing;
+    constructor(client: HyperDBClient, connection: number, onClose?: () => void);
+    close(): Promise<void>;
+    sendIPC(sql: string): AsyncIterable<Uint8Array>;
+    queryIPC(sql: string): Promise<Uint8Array>;
+    send<T extends TypeMap = {
+        [key: string]: DataType;
+    }>(sql: string): Promise<AsyncRecordBatchStreamReader<T>>;
+    query<T extends TypeMap = {
+        [key: string]: DataType;
+    }>(sql: string): Promise<Table<T>>;
+    insertArrowTable(table: Table, options: ArrowInsertOptions): Promise<void>;
+    insertArrowIPCFromPath(path: string, options: ArrowInsertOptions): Promise<void>;
+    private insertArrowIPCFromPathInternal;
+    private ensureAvailable;
+    private release;
+    closeForTermination(): Promise<void>;
+}
+export type { HyperDBEngineClient };
+export type { BrowserClientOptions as BrowserCreateOptions };

package/dist/browser.d.ts

@@ -0,0 +1,25 @@
+import { HyperDBEngineClient } from './client.js';
+import type { EngineRequest, WorkerTransport } from './protocol.js';
+type BrowserListener = (event: unknown) => void;
+export interface BrowserWorkerLike {
+    postMessage(message: unknown, transfer: ArrayBuffer[]): void;
+    addEventListener(type: string, listener: BrowserListener): void;
+    removeEventListener(type: string, listener: BrowserListener): void;
+    terminate(): void;
+}
+export interface BrowserClientOptions {
+    readonly workerUrl?: string | URL;
+    readonly engineUrl?: string | URL;
+}
+export declare class BrowserWorker implements WorkerTransport {
+    private readonly worker;
+    constructor(worker: BrowserWorkerLike);
+    postMessage(message: EngineRequest, transfer?: readonly ArrayBuffer[]): void;
+    onMessage(listener: (message: unknown) => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    onClose(): () => void;
+    terminate(): void;
+}
+export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL): URL;
+export declare function createBrowserClient(options?: BrowserClientOptions): HyperDBEngineClient;
+export {};