@instantdb/core/dist/esm/Stream.d.ts

Instant's core local abstraction

import { Logger } from './utils/log.ts';
import { RuleParams } from './schemaTypes.ts';
export type WritableStreamCtor = {
    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
};
export type ReadableStreamCtor = {
    new <R = any>(underlyingSource?: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
};
export interface InstantWritableStream<T> extends WritableStream<T> {
    streamId: () => Promise<string>;
}
type StartStreamMsg = {
    op: 'start-stream';
    'client-id': string;
    'reconnect-token': string;
    'rule-params'?: RuleParams;
};
type AppendStreamMsg = {
    op: 'append-stream';
    'stream-id': string;
    chunks: string[];
    offset: number;
    done: boolean;
    'abort-reason'?: string;
};
type SubscribeStreamMsg = {
    op: 'subscribe-stream';
    'stream-id'?: string;
    'client-id'?: string;
    offset?: number;
    'rule-params'?: RuleParams;
};
type UnsubscribeStreamMsg = {
    op: 'unsubscribe-stream';
    'subscribe-event-id': string;
};
type SendMsg = StartStreamMsg | AppendStreamMsg | SubscribeStreamMsg | UnsubscribeStreamMsg;
type TrySend = (eventId: string, msg: SendMsg) => void;
type StartStreamOkMsg = {
    op: 'start-stream-ok';
    'client-event-id': string;
    'stream-id': string;
    offset: number;
};
type AppendStreamFailedMsg = {
    op: 'append-failed';
    'stream-id': string;
};
type StreamFlushedMsg = {
    op: 'stream-flushed';
    'stream-id': string;
    offset: number;
    done: boolean;
};
type StreamAppendMsg = {
    op: 'stream-append';
    'stream-id': string;
    'client-id': string | null;
    'client-event-id': string;
    files?: {
        url: string;
        size: number;
    }[];
    done?: boolean;
    'abort-reason'?: string;
    offset: number;
    error?: string;
    retry: boolean;
    content?: string;
};
type HandleRecieveErrorMsg = {
    'client-event-id': string;
    'original-event': SendMsg;
    message?: string;
    hint?: Record<string, any>;
    type?: string;
};
export declare class InstantStream {
    private trySend;
    private WStream;
    private RStream;
    private writeStreams;
    private startWriteStreamCbs;
    private readStreamIterators;
    private log;
    private activeStreams;
    constructor({ WStream, RStream, trySend, log, }: {
        WStream: WritableStreamCtor;
        RStream: ReadableStreamCtor;
        trySend: TrySend;
        log: Logger;
    });
    createWriteStream(opts: {
        clientId: string;
        waitUntil?: (promise: Promise<any>) => void | null | undefined;
        ruleParams?: RuleParams | null | undefined;
    }): InstantWritableStream<string>;
    createReadStream(opts: {
        clientId?: string | null | undefined;
        streamId?: string | null | undefined;
        byteOffset?: number | null | undefined;
        ruleParams?: RuleParams | null | undefined;
    }): ReadableStream<string>;
    private startWriteStream;
    private registerWriteStream;
    private appendStream;
    onAppendFailed(msg: AppendStreamFailedMsg): void;
    onStartStreamOk(msg: StartStreamOkMsg): void;
    onStreamFlushed(msg: StreamFlushedMsg): void;
    private startReadStream;
    private cancelReadStream;
    onStreamAppend(msg: StreamAppendMsg): void;
    onConnectionStatusChange(status: any): void;
    onRecieveError(msg: HandleRecieveErrorMsg): void;
    hasActiveStreams(): boolean;
}
export {};
//# sourceMappingURL=Stream.d.ts.map