@interopio/bridge 0.0.1-alpha → 0.0.4-beta.0

package/src/utils/network.ts

@@ -1,130 +0,0 @@
-import {networkInterfaces} from 'node:os';
-import {ADDRCONFIG, type LookupAddress} from 'node:dns';
-import {lookup, lookupService} from 'node:dns/promises';
-
-import {textToNumericFormatV4, textToNumericFormatV6} from './internal/IpAddressUtil.ts';
-import {readFileSync} from "node:fs";
-
-const INET_ADDRESS_V4_SIZE = 4;
-
-class IpAddress {
-    readonly address: string;
-    readonly family: 4 | 6;
-    private _hostname?: string;
-
-    constructor(host: string | undefined, address: string, family: 4 | 6) {
-        this._hostname = host;
-        this.address = address;
-        this.family = family;
-    }
-
-    get addressBytes(): Uint8Array {
-        if (this.family === 4) {
-            return textToNumericFormatV4(this.address);
-        }
-        //return textToNumericFormatV6(this.address);
-    }
-
-    async getHost(): Promise<string> {
-        if (!this._hostname) {
-            this._hostname = (await lookupService(this.address, 0)).hostname;
-        }
-        return this._hostname;
-    }
-
-    async getIpAddress(nonLoopback: boolean = false): Promise<LookupAddress> {
-        const hints = nonLoopback ? ADDRCONFIG : undefined;
-        return await lookup(this.address, {family: this.family, hints: hints});
-    }
-}
-
-export type {IpAddress};
-
-export function isLoopback(address: IpAddress): boolean {
-    return address.family === 4 && address.address.startsWith('127.') || address.family === 6 && address.address.startsWith('::1');
-}
-
-export async function getByName(host: string): Promise<IpAddress> {
-    const {address, family} = await lookup(host, {family: 4});
-    if (family !== 4 && family !== 6) {
-        throw new Error('unexpected address type');
-    }
-    return new IpAddress(undefined, address, family);
-}
-
-let _anyLocalAddress: IpAddress;
-
-export function anyLocalAddress(): IpAddress {
-    if (!_anyLocalAddress) {
-        _anyLocalAddress = getByAddress('0.0.0.0', 0);
-    }
-    return _anyLocalAddress;
-}
-
-export function getByAddress(host: string, bytes: Uint8Array | number): IpAddress {
-    if (typeof bytes === 'number') {
-        const n = bytes;
-        bytes = new Uint8Array(INET_ADDRESS_V4_SIZE);
-        new DataView(bytes.buffer).setInt32(0, n);
-    }
-    const family = bytes.length === INET_ADDRESS_V4_SIZE ? 4 : 6;
-    const address = Array.from(bytes).join('.');
-    return new IpAddress(host, address, family);
-}
-
-export async function resolveByAddress(host: string, address: string): Promise<IpAddress> {
-    const byName = await getByName(address);
-    // todo: check if address and host names are correct
-    return new IpAddress(host, byName.address, byName.family);
-}
-
-export async function getAllByName(host: string): Promise<IpAddress[]> {
-    const addresses = await lookup(host, {all: true});
-    return addresses.map(({address, family}) => {
-        if (family !== 4 && family !== 6) {
-            throw new Error('unexpected address type');
-        }
-        return new IpAddress(undefined, address, family);
-    });
-}
-
-export interface NetworkInterface {
-    name: string
-    loopback: boolean
-    addresses: Array<IpAddress>
-}
-
-export function getNetworkInterfaces(): NetworkInterface[] {
-    return Object.entries(networkInterfaces()).map(([name, addresses]) => {
-        return {
-            name,
-            loopback: addresses.some(info => info.internal),
-            addresses: addresses.map(info => {
-                return new IpAddress(undefined, info.address, info.family === 'IPv6' ? 6 : 4);
-            })
-        };
-    });
-}
-
-function soMaxConn() {
-    let somaxconn;
-    if (process.platform === 'win32') {
-        somaxconn = 200;
-    }
-    else if (process.platform === 'darwin') {
-        somaxconn = 128;
-    }
-    else {
-        somaxconn = 4096;
-    }
-
-    try {
-        somaxconn = parseInt(readFileSync('/proc/sys/net/core/somaxconn').toString());
-    } catch (error) {
-        // todo log
-    }
-    return somaxconn;
-}
-
-export const SOMAXCONN = soMaxConn();
-

package/src/utils/promise.ts

@@ -1,38 +0,0 @@
-export type DeferredPromise<T> = {
-    readonly promise: Promise<T>;
-    success(value: T): void;
-    failure(reason?: any): void;
-    cancel(): boolean;
-    readonly canceled: boolean;
-}
-
-export function deferred<T>(canceler?: (callback: (err?: Error) => void) => boolean): DeferredPromise<T> {
-    let success, failure;
-    const promise = new Promise<T>((resolve, reject) => {
-        success = resolve;
-        failure = reject;
-    });
-    let canceled = false;
-    const cancel = () => {
-        if (canceled) {
-            return false;
-        }
-        canceled = true;
-        if (canceler) {
-            canceled = canceler((err?: Error) => {
-                failure(new Error('canceled', {cause: err}));
-            });
-        }
-        else {
-            failure(new Error('canceled'));
-        }
-        return canceled;
-    }
-    return {
-        promise,
-        success,
-        failure,
-        cancel,
-        get canceled() { return canceled; },
-    };
-}

package/src/utils/uuid.ts

@@ -1,5 +0,0 @@
-import {nanoid} from 'nanoid';
-
-export function newUUID() : string {
-    return nanoid();
-}

package/src/utils/vint.ts

@@ -1,238 +0,0 @@
-/**
- * Borrows idea from
- * https://developers.google.com/protocol-buffers/docs/encoding#varints
- */
-import type {ByteBuffer} from "./buffer";
-import type {DataInput} from "../io/VersionedSerializer";
-
-
-const HI = 0;
-const LO = 1;
-type Int64 = [hi: number, lo: number];
-const zero: () => Int64 = () => [0, 0];
-
-function encodeZigZag64([hi, lo]: Int64): Int64 {
-    const mask = hi >> 31;
-    hi = ((hi << 1 | lo >>> 31) ^ mask) >>> 0;
-    lo = ((lo << 1)             ^ mask) >>> 0;
-    return [hi, lo];
-}
-
-function decodeZigZag64([hi, lo]: Int64): Int64 {
-    const mask = -(hi & 1);
-    lo = ((lo >>> 1 | hi << 31) ^ mask) >>> 0;
-    hi = ((hi >>> 1)             ^ mask) >>> 0;
-    return [hi, lo];
-}
-
-function numberOfExtraBytesToRead(firstByte: number) {
-    return numberOfLeadingZeros32(~firstByte) - 24;
-}
-
-function firstByteValueMask(size:number) {
-    return 0xff >> size;
-}
-
-export function getUnsignedVInt32(buffer: ByteBuffer, position?: number, limit?: number): number {
-    const i64 = getUnsignedVInt64(buffer, position, limit);
-    if (i64 === -1) {
-        return -1;
-    }
-    return i64[HI] === -1 ? -i64[LO] : i64[LO];
-}
-
-export function getUnsignedVIntSize(buffer: ByteBuffer, position?: number, limit?: number): number {
-    limit ??= buffer.limit;
-    position ??= buffer.position;
-    if (position >= limit) {
-        return -1;
-    }
-
-    const firstByte = buffer.getInt8(position++);
-    return 1 + (firstByte >= 0 ? 0 : numberOfExtraBytesToRead(firstByte));
-}
-
-export function getUnsignedVInt(buffer: ByteBuffer, position?: number, limit?: number): number | bigint {
-    const i64 = getUnsignedVInt64(buffer, position, limit);
-    if (i64 === -1) {
-        return -1;
-    }
-    if (i64[HI] === 0) {
-        return i64[LO];
-    }
-    return BigInt(i64[HI]) << 32n | BigInt(i64[LO]);
-}
-
-function getUnsignedVInt64(buffer: ByteBuffer, position?: number, limit?: number): Int64 | -1 {
-    limit ??= buffer.limit;
-    position ??= buffer.position;
-    if (position >= limit) {
-        return -1;
-    }
-
-    const firstByte = buffer.getInt8(position++);
-    if (firstByte >= 0) {
-        return [0, firstByte];
-    }
-
-    const size = numberOfExtraBytesToRead(firstByte);
-    if (position + size > limit) {
-        return -1;
-    }
-
-    let result: Int64 = zero();
-    result[size > 4 ? HI : LO] = firstByte & firstByteValueMask(size);
-    for (let i = 0; i < size; i++) {
-        const vi = size - i > 4 ? HI : LO;
-        const b = buffer.getInt8(position++);
-        result[vi] <<= 8;
-        result[vi] |= b & 0xff
-    }
-    return result;
-}
-
-function encodeExtraBytesToRead(extraBytesToRead: number) {
-    return ~firstByteValueMask(extraBytesToRead);
-}
-const TMP = new Uint8Array(9);
-function encodeUnsignedVint64(value: Int64, size: number): Uint8Array {
-    const encodingSpace = TMP;
-
-    const extraBytes = size - 1;
-    for (let i = extraBytes; i>= 0; i--) {
-        const vi = i > 4 ? HI : LO;
-        encodingSpace[i] = value[vi] & 0xff;
-        value[vi] >>= 8;
-    }
-    encodingSpace[0] |= encodeExtraBytesToRead(extraBytes);
-    return encodingSpace;
-}
-
-export function setUnsignedVInt32(i: number, buffer: ByteBuffer) {
-    setUnsignedVInt64(int64(i, true), buffer);
-}
-
-export function setUnsignedVInt(i: bigint | number, buffer: ByteBuffer) {
-    const i64 = int64(i);
-    setUnsignedVInt64(i64, buffer);
-}
-
-function setUnsignedVInt64(i64: Int64, buffer: ByteBuffer) {
-    const size = computeUnsignedVIntSize64(i64);
-    if (size === 1) {
-        buffer.setUint8(i64[LO]);
-    }
-    else if (size < 9)
-    {
-        const limit = buffer.limit;
-        const position = buffer.position;
-        if (limit - position >= 8) {
-            const shift = (8 - size) << 3;
-            const extraBytes = size - 1;
-            const mask = encodeExtraBytesToRead(extraBytes) << 24;
-
-            if (shift < 32) {
-                buffer.setInt32(position, ((i64[HI] << shift) | (i64[LO] >> (32 - shift))) | mask);
-                buffer.setInt32(position + 4, i64[LO] << shift);
-            }
-            else {
-                buffer.setInt32(position, (i64[LO] << (shift - 32)) | mask);
-            }
-            buffer.position = position + size;
-        }
-        else {
-            buffer.setUint8Array(encodeUnsignedVint64(i64, size), 0, size);
-        }
-
-    }
-    else if (size === 9) {
-        buffer.setUint8(0xFF);
-        buffer.setUint32(i64[HI]);
-        buffer.setUint32(i64[LO]);
-    }
-    else {
-        throw new Error();
-    }
-}
-
-export function computeVIntSize(i: bigint | number): number {
-    return computeUnsignedVIntSize64(encodeZigZag64(int64(i)));
-}
-
-function int64(i: bigint | number, from32 = false): [hi: number, lo: number] {
-    if (typeof i === 'number') {
-        if (from32) {
-            const lo = i & 0xFFFFFFFF;
-            const hi = lo >> 31 === -1 ? -1 : 0;
-            return [hi, lo];
-        }
-        i = BigInt(i);
-    }
-    const lo = Number(i & 0xFFFFFFFFn);
-    const hi = Number((i & 0xFFFFFFFF00000000n) >> 32n);
-
-    return [hi, lo];
-}
-
-function computeUnsignedVIntSize64([hi, lo]: Int64) {
-    const magnitude = numberOfLeadingZeros64([hi, lo | 1]);
-    return (639 - magnitude * 9) >> 6;
-}
-
-export function computeUnsignedVIntSize(i: bigint | number): number {
-    return computeUnsignedVIntSize64(int64(i));
-}
-
-function numberOfLeadingZeros64([hi, lo]: Int64): number {
-    return hi === 0 ? numberOfLeadingZeros32(lo) + 32 : numberOfLeadingZeros32(hi);
-}
-
-function numberOfLeadingZeros32(i: number): number {
-
-    if (i === 0) {
-        return 32;
-    }
-    if (i < 0) {
-        return 0;
-    }
-
-    let n = 31;
-    if (i >= 1 << 16) { n -= 16; i >>>= 16; }
-    if (i >= 1 <<  8) { n -=  8; i >>>=  8; }
-    if (i >= 1 <<  4) { n -=  4; i >>>=  4; }
-    if (i >= 1 <<  2) { n -=  2; i >>>=  2; }
-    return n - (i >>> 1);
-}
-
-export function skipUnsignedVInt(input: DataInput): void {
-    const firstByte = input.readInt8();
-    if (firstByte < 0) {
-        input.skipBytesFully(numberOfExtraBytesToRead(firstByte));
-    }
-}
-
-
-export function readUnsignedVInt32(input: DataInput): number {
-    const i64 = readUnsignedVInt64(input);
-    return i64[HI] === -1 ? -i64[LO] : i64[LO];
-}
-
-function readUnsignedVInt64(input: DataInput): Int64 {
-    const firstByte = input.readInt8();
-    if (firstByte >= 0) {
-        return [0, firstByte];
-    }
-
-    const size = numberOfExtraBytesToRead(firstByte);
-
-    let result: Int64 = zero();
-    result[size > 4 ? HI : LO] = firstByte & firstByteValueMask(size);
-    for (let i = 0; i < size; i++) {
-        const vi = size - i > 4 ? HI : LO;
-        const b = input.readInt8();
-        result[vi] <<= 8;
-        result[vi] |= b & 0xff
-    }
-    return result;
-
-}

package/src/version/MemberVersion.ts

@@ -1,42 +0,0 @@
-function parse(version: string): [number, number, number] {
-    const pattern = /(\d+)\.(\d+)(\.(\d+))?(-\w+(?:-\d+)?)?$/g;
-
-    const x = pattern.exec(version);
-    const major = parseInt(x[1]);
-    const minor = parseInt(x[2]);
-    const patch = x[3] ? parseInt(x[4]) : 0;
-
-    return [major, minor, patch];
-}
-
-class MemberVersion {
-
-    readonly major: number;
-    readonly minor: number;
-    readonly patch: number;
-
-    public get isUnknown(): boolean {
-        return this.major === 0 && this.minor === 0 && this.patch === 0;
-    }
-
-    public toString(): string {
-        return `${this.major}.${this.minor}.${this.patch}`;
-    }
-
-    constructor(major: number, minor: number, patch: number) {
-        this.major = major;
-        this.minor = minor;
-        this.patch = patch;
-    }
-}
-
-export const UNKNOWN_VERSION: MemberVersion = new MemberVersion(0, 0, 0);
-
-export function parseVersion(version?: string): MemberVersion {
-    if (!version || version.startsWith('0.0.0')) {
-        return UNKNOWN_VERSION;
-    }
-    return new MemberVersion(...parse(version));
-}
-
-export type {MemberVersion};

package/src/version/Version.ts

@@ -1,12 +0,0 @@
-export class Version {
-    public static of(major: number, minor: number) {
-        return new Version(major, minor);
-    }
-    readonly major: number;
-    readonly minor: number;
-
-    private constructor(major: number, minor: number) {
-        this.major = major;
-        this.minor = minor;
-    }
-}