Class RuntimeLocalClient

projects/runtime-client/src/client.ts:256–323

}

export class RuntimeLocalClient {
    private nextId = 1
    private connected = false
    private connecting: Promise<void> | null = null
    private disposeMessageListener: (() => void) | null = null
    private readonly listeners = new Set<NotificationListener>()

    constructor(
        private readonly transport: RuntimeLocalTransport,
        private readonly options: RuntimeLocalClientOptions = {}
    ) {}

    async request<T>(method: string, params?: unknown): Promise<T> {
        await this.connect()
        return this.requestRaw<T>(method, params)
    }

    private async requestRaw<T>(method: string, params?: unknown): Promise<T> {
        const request: RuntimeRequest = params === undefined ? { id: this.nextId++, method } : { id: this.nextId++, method, params }
        const response = validateRuntimeResponse(await this.transport.request(request))
        if (!response.ok) throw new RuntimeClientError(response.error.code, response.error.message, { path: response.error.path })
        if (response.value.error) throw new RuntimeClientError(response.value.error.code, response.value.error.message, response.value.error.data)
        return response.value.result as T
    }

    async connect(): Promise<void> {
        if (this.connected) return
        if (this.connecting) return this.connecting
        this.connecting = this.connectOnce()
        try {
            await this.connecting
        } finally {
            this.connecting = null
        }
    }

    private async connectOnce(): Promise<void> {
        await this.transport.connect()
        this.disposeMessageListener = this.transport.onMessage((message) => {
            if (!isRuntimeNotification(message)) return
            for (const listener of this.listeners) listener(message)
        })
        await this.requestRaw("initialize", {
            clientName: this.options.clientName ?? "Runtime Local Client",
            clientPlatform: this.options.clientPlatform ?? "desktop",
            ...(this.options.clientVersion ? { clientVersion: this.options.clientVersion } : {}),
            protocolVersion: this.options.protocolVersion ?? 1,
        })
        this.connected = true
    }

    subscribe(listener: NotificationListener): () => void {
        this.listeners.add(listener)
        void this.connect()
        return () => {
            this.listeners.delete(listener)
        }
    }