@hazae41/kcp/dist/cjs/mods/kcp/stream.cjs

Zero-copy KCP protocol for the web

'use strict';

var bytes = require('@hazae41/bytes');
var cascade = require('@hazae41/cascade');
var cursor = require('@hazae41/cursor');
var future = require('@hazae41/future');
var reader = require('./reader.cjs');
var writer = require('./writer.cjs');

class KcpDuplex {
    params;
    #secret;
    constructor(params = {}) {
        this.params = params;
        this.#secret = new SecretKcpDuplex(params);
    }
    [Symbol.dispose]() {
        this.close();
    }
    get conversation() {
        return this.#secret.conversation;
    }
    get inner() {
        return this.#secret.inner;
    }
    get outer() {
        return this.#secret.outer;
    }
    get closing() {
        return this.#secret.closing;
    }
    get closed() {
        return this.#secret.closed;
    }
    error(reason) {
        this.#secret.error(reason);
    }
    close() {
        this.#secret.close();
    }
}
class SecretKcpDuplex {
    params;
    duplex;
    reader;
    writer;
    conversation;
    resolveOnClose = new future.Future();
    resolveOnError = new future.Future();
    resolveOnAckBySerial = new Map();
    sendCounter = 0;
    recvCounter = 0;
    constructor(params = {}) {
        this.params = params;
        const { conversation = new cursor.Cursor(bytes.Bytes.random(4)).readUint32OrThrow(true) } = this.params;
        this.conversation = conversation;
        this.reader = new reader.SecretKcpReader(this);
        this.writer = new writer.SecretKcpWriter(this);
        this.duplex = new cascade.FullDuplex({
            input: {
                write: m => this.reader.onWrite(m)
            },
            output: {
                write: m => this.writer.onWrite(m)
            },
            close: () => this.#onDuplexClose(),
            error: e => this.#onDuplexError(e)
        });
    }
    [Symbol.dispose]() {
        this.close();
    }
    get inner() {
        return this.duplex.inner;
    }
    get outer() {
        return this.duplex.outer;
    }
    get input() {
        return this.duplex.input;
    }
    get output() {
        return this.duplex.output;
    }
    get closing() {
        return this.duplex.closing;
    }
    get closed() {
        return this.duplex.closed;
    }
    async #onDuplexClose() {
        this.resolveOnClose.resolve();
        await this.params.close?.call(undefined);
    }
    async #onDuplexError(cause) {
        this.resolveOnError.resolve(cause);
        await this.params.error?.call(undefined, cause);
    }
    error(reason) {
        this.duplex.error(reason);
    }
    close() {
        this.duplex.close();
    }
}

exports.KcpDuplex = KcpDuplex;
exports.SecretKcpDuplex = SecretKcpDuplex;
//# sourceMappingURL=stream.cjs.map