@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/net/internal/channel/types.ts

@@ -1,188 +0,0 @@
-import type {Address} from '../../../cluster/Address.ts';
-import {type EventExecutor, type EventExecutorGroup} from '../AsyncResourceExecutor.ts';
-
-export interface SocketAddress {}
-
-export type InetSocketAddress = SocketAddress & Address;
-
-export interface ChannelOutboundInvoker {
-    bind(localAddress: SocketAddress): Promise<void>
-    connect(remoteAddress: SocketAddress, localAddress?: SocketAddress): Promise<void>
-    disconnect(): Promise<void>
-    close(error?: Error): Promise<void>
-    deregister(): Promise<void>
-    write(message: unknown): Promise<void>
-    flush(): this
-    writeAndFlush(message: unknown): Promise<void>
-    read(): this
-    newPromise(): ChannelPromise<void>
-}
-
-interface ChannelInboundInvoker {
-    fireChannelRegistered(): this;
-    fireChannelUnregistered(): this;
-    fireChannelActive(): this;
-    fireChannelInactive(): this;
-    fireErrorCaught(error: Error): this;
-    fireChannelRead(data: unknown): this;
-    fireChannelReadComplete(): this;
-    fireChannelWritabilityChanged(): this;
-}
-
-export interface EventLoopGroup extends EventExecutorGroup {
-    next(): EventLoop
-    register(channel: Channel): Promise<void>;
-}
-
-export interface EventLoop extends EventExecutor, EventLoopGroup {
-    next(): EventLoop
-    readonly ordered: true
-}
-
-export interface ChannelConfig {
-    autoRead: boolean
-    messageSizeEstimator: MessageSizeEstimator
-    writeBufferHighWaterMark: number
-    writeBufferLowWaterMark: number
-}
-
-export interface MessageSizeEstimator {
-    newHandle(): MessageSizeEstimatorHandle
-}
-export interface MessageSizeEstimatorHandle {
-    size(message: unknown): number
-}
-
-export interface ChannelMetadata {
-    readonly hasDisconnect: boolean
-}
-
-export interface Channel extends ChannelOutboundInvoker {
-    readonly id: string
-    readonly eventLoop: EventLoop
-    readonly parent?: Channel
-    readonly config: ChannelConfig
-    readonly metadata: ChannelMetadata
-    isOpen(): boolean
-    isRegistered(): boolean
-    readonly localAddress: SocketAddress
-    readonly remoteAddress: SocketAddress
-    readonly closePromise: Promise<void>
-
-    readonly unsafe: Unsafe
-    readonly pipeline: ChannelPipeline
-}
-
-export interface Unsafe {
-
-    readonly localAddress: SocketAddress
-    readonly remoteAddress: SocketAddress
-    register(eventLoop: EventLoop): Promise<void>
-    deregister(promise: ChannelPromise<void>): void
-    bind(localAddress: SocketAddress): Promise<void>
-    connect(remoteAddress: SocketAddress, localAddress: SocketAddress): Promise<void>
-    disconnect(promise: ChannelPromise<void>): void
-    close(error: Error): Promise<void>
-    closeForcibly(): void
-    beginRead(): void
-    write(message: unknown): Promise<void>
-    flush(): void
-}
-
-export interface ServerChannel extends Channel {}
-
-export interface DuplexChannelConfig extends ChannelConfig {
-    allowHalfOpen: boolean
-}
-export interface DuplexChannel extends Channel {}
-
-export interface ServerSocketChannelConfig extends ChannelConfig {
-    backlog: number
-}
-
-export interface ServerSocketChannel extends ServerChannel {
-    readonly config: ServerSocketChannelConfig
-    readonly localAddress: InetSocketAddress
-    readonly remoteAddress: InetSocketAddress
-}
-
-export interface SocketChannelConfig extends DuplexChannelConfig {
-    noDelay?: boolean
-}
-export interface SocketChannel extends DuplexChannel {
-    readonly parent: ServerSocketChannel
-    readonly localAddress: InetSocketAddress
-    readonly remoteAddress: InetSocketAddress
-}
-export interface DatagramChannel extends Channel {}
-
-export interface ChannelPipeline extends ChannelInboundInvoker, ChannelOutboundInvoker {
-    readonly channel: Channel
-
-    newPromise(): ChannelPromise<void>
-
-    addFirst(handler: ChannelHandler): this
-    addFirst(handler: ChannelHandler, name: string): this
-    addBefore(base: string, handler: ChannelHandler): this
-    addBefore(base: string, handler: ChannelHandler, name: string): this
-    addAfter(base: string, handler: ChannelHandler): this
-    addAfter(base: string, handler: ChannelHandler, name: string): this
-    addLast(handler: ChannelHandler): this
-    addLast(handler: ChannelHandler, name: string): this
-    remove(name: string): this
-    remove(handler: ChannelHandler): this
-}
-
-export interface ChannelHandlerContext extends ChannelInboundInvoker, ChannelOutboundInvoker {
-    readonly channel: Channel
-    readonly executor: EventExecutor
-    readonly name: string
-    readonly handler: ChannelHandler
-    readonly pipeline: ChannelPipeline
-    isRemoved(): boolean
-}
-
-export interface ChannelHandler {
-    handlerAdded(ctx: ChannelHandlerContext): void
-    handlerRemoved(ctx: ChannelHandlerContext): void
-
-}
-
-export interface ChannelInboundHandler extends ChannelHandler {
-    channelRegistered(ctx: ChannelHandlerContext): void
-    channelUnregistered(ctx: ChannelHandlerContext): void
-    channelActive(ctx: ChannelHandlerContext): void
-    channelInactive(ctx: ChannelHandlerContext): void
-    channelRead(ctx: ChannelHandlerContext, data: unknown): void
-    channelReadComplete(ctx: ChannelHandlerContext): void
-    channelWritabilityChanged(ctx: ChannelHandlerContext): void
-    errorCaught(ctx: ChannelHandlerContext, error: Error): void
-}
-
-export interface ChannelOutboundHandler extends ChannelHandler {
-    onBind(ctx: ChannelHandlerContext, localAddress: SocketAddress): Promise<void>
-    onConnect(ctx: ChannelHandlerContext, remoteAddress: SocketAddress, localAddress: SocketAddress): Promise<void>
-    onDisconnect(ctx: ChannelHandlerContext): Promise<void>
-    onClose(ctx: ChannelHandlerContext, error?: Error): Promise<void>
-    onDeregister(ctx: ChannelHandlerContext): Promise<void>
-    onWrite(ctx: ChannelHandlerContext, message: unknown): Promise<void>
-    onFlush(ctx: ChannelHandlerContext): void;
-    onRead(ctx: ChannelHandlerContext): void
-}
-
-
-export interface ChannelPromise<T> {
-    readonly promise: Promise<T>
-    readonly channel: Channel
-    success(value: T): boolean
-    failure(error: Error): boolean
-    isSuccess(): boolean
-    isDone(): boolean
-    cancel(): boolean
-
-    readonly reason: any | undefined
-    addListener(listener: (promise: ChannelPromise<T>) => void): this
-    sync(): Promise<this>
-}
-
-

package/src/utils/bigint.ts

@@ -1,23 +0,0 @@
-export function maxn(...values: bigint[]) {
-    let max = values[0];
-    for (let i = 1; i < values.length; i++) {
-        if (values[i] > max) {
-            max = values[i];
-        }
-    }
-    return max;
-}
-
-export function minn(...values: bigint[]) {
-    let min = values[0];
-    for (let i = 1; i < values.length; i++) {
-        if (values[i] < min) {
-            min = values[i];
-        }
-    }
-    return min;
-}
-
-export function absn(n: bigint) {
-    return n < 0n ? -n : n;
-}

package/src/utils/buffer.ts

@@ -1,434 +0,0 @@
-export interface ByteBuffer /*extends DataView*/ {
-    readonly remaining: number;
-    readonly hasRemaining: boolean;
-    readonly capacity: number;
-
-    mark(): this;
-    reset(): this;
-    clear(): this;
-    flip(): this;
-    duplicate(): this;
-    position: number;
-    limit: number;
-
-    order: 'little-endian' | 'big-endian';
-
-    // unsigned byte
-    getUint8(): number;
-    setUint8(value: number): this;
-    getUint8(offset: number): number;
-    setUint8(value: number, offset: number): this;
-
-    // singed byte
-    getInt8(): number
-    setInt8(value: number): this;
-    getInt8(offset: number): number
-    setInt8(offset: number, value: number): this;
-
-    // signed short
-    getInt16(): number;
-    setInt16(value: number): this;
-    getInt16(offset: number): number;
-    setInt16(offset: number, value: number): this;
-
-    // unsigned short
-    getUint16(): number;
-    setUint16(value: number): this;
-    getUint16(offset: number): number;
-    setUint16(offset: number, value: number): this;
-
-    // signed int
-    getInt32(): number;
-    setInt32(value: number): this;
-    getInt32(offset: number): number;
-    setInt32(offset: number, value: number): this;
-
-    // unsigned int
-    getUint32(): number;
-    setUint32(value: number): this;
-    getUint32(offset: number): number;
-    setUint32(offset: number, value: number): this;
-
-    // signed long
-    getBigInt64(): bigint;
-    setBigInt64(value: bigint): this;
-    getBigInt64(offset: number): bigint;
-    setBigInt64(offset: number, value: bigint): this;
-
-    // byte array
-    getUint8Array(value: Uint8Array): this;
-    setUint8Array(value: Uint8Array): this;
-    getUint8Array(value: Uint8Array, offset: number, length: number): this;
-    setUint8Array(value: Uint8Array, offset: number, length: number): this;
-
-    setByteBuffer(value: ByteBuffer): this;
-
-}
-
-abstract class BaseBuffer {
-    private _mark = -1;
-    private _position = 0;
-    private _limit: number;
-    private _capacity: number;
-
-    /*protected*/ constructor(mark: number, pos: number, lim: number, cap: number) {
-        if (cap < 0) {
-            throw new Error(`capacity must not be negative (${cap} < 0)`);
-        }
-        this._capacity = cap;
-        this.limit = lim;
-        this.position = pos;
-        if (mark >= 0) {
-            if (mark > pos) {
-                throw new Error(`mark > position (${mark} > ${pos})`);
-            }
-            this._mark = mark;
-        }
-    }
-
-    get capacity(): number {
-        return this._capacity;
-    }
-
-    get position(): number {
-        return this._position;
-    }
-
-    set position(value: number) {
-        if (value < 0 || value > this._limit) {
-            throw new Error(`invalid position ${value} (limit: ${this._limit})`);
-        }
-        if (this._mark > value) {
-            this._mark = -1;
-        }
-        this._position = value;
-    }
-
-    get limit(): number {
-        return this._limit;
-    }
-
-    set limit(value: number) {
-        if (value < 0 || value > this._capacity) {
-            throw new Error(`invalid limit ${value} (capacity: ${this._capacity})`);
-        }
-        this._limit = value;
-        if (this._position > value) {
-            this._position = value;
-        }
-        if (this._mark > value) {
-            this._mark = -1;
-        }
-    }
-
-    mark(): this {
-        this._mark = this._position;
-        return this;
-    }
-    reset(): this {
-        const m = this._mark;
-        if (m < 0) {
-            throw new Error('invalid mark');
-        }
-        this._position = m;
-        return this;
-    }
-
-    clear(): this {
-        this._position = 0;
-        this._limit = this._capacity;
-        this._mark = -1;
-        return this;
-    }
-
-    flip(): this {
-        this._limit = this._position;
-        this._position = 0;
-        this._mark = -1;
-        return this;
-    }
-
-    rewind(): this {
-        this._position = 0;
-        this._mark = -1;
-        return this;
-    }
-
-    get remaining(): number {
-        const rem = this._limit - this._position;
-        return rem > 0 ? rem : 0;
-    }
-
-    get hasRemaining(): boolean {
-        return this._position < this._limit;
-    }
-
-    private truncate(): void {
-        this._mark = -1;
-        this._position = 0;
-        this._limit = 0;
-        this._capacity = 0;
-    }
-
-    protected nextGetByteOffset(numberOfBytes = 1): number {
-        const p = this.position;
-        if (this._limit - p < numberOfBytes) {
-            throw new Error('Buffer underflow');
-        }
-        this._position = p + numberOfBytes;
-        return p;
-    }
-
-    protected nextSetByteOffset(numberOfBytes = 1): number {
-        const p = this.position;
-        if (this._limit - p < numberOfBytes) {
-            throw new Error('Buffer overflow');
-        }
-        this._position = p + numberOfBytes;
-        return p;
-    }
-
-    protected checkByteOffset(byteOffset: number, numberOfBytes = 1): number {
-        if (byteOffset < 0 || numberOfBytes > this._limit - byteOffset) {
-            throw new Error(`byteOffset ${byteOffset} for ${numberOfBytes} bytes out of bounds: (limits ${this._limit})`);
-        }
-        return byteOffset;
-    }
-}
-
-
-export function allocate(capacity: number) {
-    return new ArrayByteBuffer(capacity, capacity);
-}
-
-export function wrap(view: DataView<ArrayBuffer>) {
-    return new ArrayByteBuffer(view.byteLength, view.byteLength - view.byteOffset, view);
-}
-
-function checkBounds(offset: number, length: number, size: number): void {
-    if (offset < 0 || length < 0 || offset + length > size) {
-        throw new Error(`index out of bounds: ${offset} + ${length} > ${size}`);
-    }
-}
-
-class ArrayByteBuffer extends BaseBuffer implements ByteBuffer {
-    private readonly _view: DataView<ArrayBuffer>;
-    private _littleEndian?: boolean;
-
-    constructor(cap: number, lim: number, view?: DataView<ArrayBuffer>) {
-        super(-1, 0, lim, cap);
-
-        this._view = view ?? new DataView(new ArrayBuffer(lim, { maxByteLength: cap }));
-    }
-
-    duplicate(): this {
-        const dup = new ArrayByteBuffer(this.capacity, this.limit, this._view);
-        dup.position = this.position;
-        dup._littleEndian = this._littleEndian;
-        return dup as this;
-    }
-
-
-    get order(): 'little-endian' | 'big-endian' {
-        return this._littleEndian ? 'little-endian' : 'big-endian';
-    }
-
-    set order(value: 'little-endian' | 'big-endian') {
-        this._littleEndian = value === 'little-endian';
-    }
-
-    // get buffer() {
-    //     return this._view.buffer;
-    // }
-    //
-    // get byteLength(): number {
-    //     return this._view.byteLength;
-    // }
-    //
-    // get byteOffset(): number {
-    //     return this._view.byteOffset;
-    // }
-
-    private index(byteOffset: number): number {
-        return byteOffset + this._view.byteOffset;
-    }
-
-    getInt8(byteOffset?: number): number {
-        byteOffset = byteOffset !== undefined ? super.checkByteOffset(byteOffset) : super.nextGetByteOffset();
-        return this._view.getInt8(this.index(byteOffset));
-    }
-
-    setInt8(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset();
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue);
-        }
-        this._view.setInt8(this.index(byteOffset), value);
-        return this;
-    }
-
-    getUint8(byteOffset?: number): number {
-        byteOffset = byteOffset !== undefined ? super.checkByteOffset(byteOffset) : super.nextGetByteOffset();
-        return this._view.getUint8(this.index(byteOffset));
-    }
-
-    setUint8(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset();
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue);
-        }
-        this._view.setUint8(this.index(byteOffset), value);
-        return this;
-    }
-
-    getInt16(bytesOffset?: number): number {
-        bytesOffset = bytesOffset !== undefined ? super.checkByteOffset(bytesOffset, 2) : super.nextGetByteOffset(2);
-        return this._view.getInt16(this.index(bytesOffset), this._littleEndian);
-    }
-
-    setInt16(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset(2);
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue, 2);
-        }
-        this._view.setInt16(this.index(byteOffset), value, this._littleEndian);
-        return this;
-    }
-
-    getUint16(bytesOffset?: number): number {
-        bytesOffset = bytesOffset !== undefined ? super.checkByteOffset(bytesOffset, 2) : super.nextGetByteOffset(2);
-        return this._view.getUint16(this.index(bytesOffset), this._littleEndian);
-    }
-
-    setUint16(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset(2);
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue, 2);
-        }
-        this._view.setUint16(this.index(byteOffset), value, this._littleEndian);
-        return this;
-    }
-
-    getInt32(byteOffset?: number): number {
-        byteOffset = byteOffset !== undefined ? super.checkByteOffset(byteOffset, 4) : super.nextGetByteOffset(4);
-        return this._view.getInt32(this.index(byteOffset), this._littleEndian);
-    }
-
-    setInt32(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset(4);
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue, 4);
-        }
-        this._view.setInt32(this.index(byteOffset), value, this._littleEndian);
-        return this;
-    }
-
-    getUint32(byteOffset?: number): number {
-        byteOffset = byteOffset !== undefined ? super.checkByteOffset(byteOffset, 4) : super.nextGetByteOffset(4);
-        return this._view.getUint32(this.index(byteOffset), this._littleEndian);
-    }
-
-    setUint32(byteOffsetOrValue: number, value?: number): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = byteOffsetOrValue;
-            byteOffset = super.nextSetByteOffset(4);
-        }
-        else {
-            byteOffset = super.checkByteOffset(byteOffsetOrValue, 4);
-        }
-        this._view.setUint32(this.index(byteOffset), value, this._littleEndian);
-        return this;
-    }
-
-    getBigInt64(byteOffset?: number): bigint {
-        byteOffset = byteOffset !== undefined ? super.checkByteOffset(byteOffset, 8) : super.nextGetByteOffset(8);
-        return this._view.getBigInt64(this.index(byteOffset), this._littleEndian);
-    }
-
-    setBigInt64(byteOffsetOrValue: bigint | number, value?: bigint): this {
-        let byteOffset: number;
-        if (value === undefined) {
-            value = typeof byteOffsetOrValue === 'bigint' ? byteOffsetOrValue : BigInt(byteOffsetOrValue);
-            byteOffset = super.nextSetByteOffset(8);
-        }
-        else {
-            byteOffset = super.checkByteOffset(typeof byteOffsetOrValue === 'number' ? byteOffsetOrValue : Number(byteOffsetOrValue), 8);
-        }
-        this._view.setBigInt64(this.index(byteOffset), value);
-        return this;
-    }
-
-    getUint8Array(value: Uint8Array, offset: number = 0, length?: number): this {
-        length ??= value.length - offset;
-        checkBounds(offset, length, value.length);
-        if (length > this.remaining) {
-            throw new Error(`Buffer underflow`);
-        }
-        const end = offset + length;
-        for (let i = offset; i < end; i++) {
-            value[i] = this.getUint8();
-        }
-        return this;
-    }
-
-    setUint8Array(value: Uint8Array, offset: number = 0, length?: number): this {
-        length ??= value.length - offset;
-        checkBounds(offset, length, value.length);
-        if (length > this.remaining) {
-            throw new Error(`Buffer overflow`);
-        }
-        const end = offset + length;
-        for (let i = offset; i < end; i++) {
-            this.setUint8(value[i]);
-        }
-        return this;
-    }
-
-    setByteBuffer(value: ByteBuffer): this {
-        if (value === this) {
-            throw new Error('cannot set self');
-        }
-        const pos = this.position;
-        const sbpos = value.position;
-        const n = value.limit - sbpos;
-        if (n > this.limit - pos) {
-            throw new Error(`buffer underflow: ${n} > ${this.limit - pos}`);
-        }
-        let array: Uint8Array;
-        if (value instanceof ArrayByteBuffer) {
-            const byteOffset = value.nextGetByteOffset(n);
-            array = new Uint8Array(value._view.buffer, byteOffset, n);
-        }
-        else {
-            array = new Uint8Array(n);
-            value.getUint8Array(array);
-        }
-        this.setUint8Array(array);
-        return this;
-    }
-}
-
-export function adopt(data: Buffer<ArrayBufferLike>) {
-    return wrap(new DataView<ArrayBuffer>(data.buffer as ArrayBuffer, data.byteOffset, data.byteLength));
-}