@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/utils/clock.ts

@@ -1,148 +0,0 @@
-import {convert} from '../config/Duration.ts';
-
-export interface Clock {
-    now(): bigint
-    error(): number
-    readonly translate: ClockTranslation
-    isBefore(instantNs: bigint, nowNs?: bigint): boolean
-}
-
-
-export const globalClock: {epochTime: () => bigint, nanoTime: () => bigint} = new (class {
-    epochTime(): bigint {
-        return BigInt(Date.now());
-    }
-    nanoTime(): bigint {
-        return process.hrtime.bigint();
-    }
-
-});
-
-export interface ClockTranslation {
-    fromMillisSinceEpoch(currentTimeMillis: bigint): bigint
-    toMillisSinceEpoch(nanoTime: bigint): bigint
-    readonly error: number
-}
-
-class AlmostSameTime implements ClockTranslation {
-    private readonly millisSinceEpoch: bigint;
-    private readonly monotonicNanos: bigint;
-    readonly error: number;
-    constructor(millisSinceEpoch: bigint | number, monotonicNanos: bigint | number, error: number) {
-        this.millisSinceEpoch = BigInt(millisSinceEpoch);
-        this.monotonicNanos = BigInt(monotonicNanos);
-        this.error = error;
-    }
-    fromMillisSinceEpoch(currentTimeMillis: bigint): bigint {
-        return this.monotonicNanos + convert('nanoseconds', currentTimeMillis - this.millisSinceEpoch, 'milliseconds');
-    }
-
-    toMillisSinceEpoch(nanoTime: bigint): bigint {
-        return this.millisSinceEpoch + convert('milliseconds', nanoTime - this.monotonicNanos, 'nanoseconds');
-    }
-}
-export class HrTimeClock implements Clock {
-    translate: ClockTranslation = new AlmostSameTime(Date.now(), this.now(), Number.MAX_SAFE_INTEGER);
-    now(): bigint {
-        return  process.hrtime.bigint();
-    }
-
-    error(): number {
-        return 1;
-    }
-
-    isBefore(instantNs: bigint, nowNs?: bigint): boolean {
-        return instantNs < (nowNs ?? this.now());
-    }
-}
-
-export class PerformanceClock implements Clock {
-    translate: ClockTranslation = new AlmostSameTime(Date.now(), this.now(), Number.MAX_SAFE_INTEGER);
-    // performance.now() returns a double representing milliseconds.microsenconds
-    now(): bigint {
-        return BigInt(Math.trunc(globalThis.performance.now() * 1e3) * 1e3);
-    }
-    error() {
-        return 1e3;
-    }
-    isBefore(instantNs: bigint, nowNs?: bigint): boolean {
-        return (instantNs ?? this.now()) < instantNs;
-    }
-}
-
-function approx(clock: Clock): SampledClock {
-    return new SampledClock(clock);
-}
-
-class SampledClock implements Clock {
-    private almostNowIntervalId: ReturnType<typeof setInterval> = undefined;
-    private almostNow: bigint = 0n;
-    private readonly updateIntervalMs: number;
-    private readonly errorNs: bigint;
-    private readonly precise: Clock;
-
-    constructor(precise: Clock, updateIntervalMs?: number) {
-        this.precise = precise;
-        this.updateIntervalMs = Math.max(1, updateIntervalMs ?? 2);
-        this.errorNs = BigInt(this.updateIntervalMs * 1e6);
-        this.resumeSampling();
-    }
-
-    now(): bigint {
-        return this.almostNow;
-    }
-
-    error(): number {
-        return Number(this.errorNs);
-    }
-
-    get translate(): ClockTranslation {
-        return this.precise.translate;
-    }
-
-    isBefore(instantNs: bigint, nowNs?: bigint): boolean {
-        return ((nowNs ?? this.almostNow) - this.errorNs) < instantNs;
-    }
-
-    pauseSampling() {
-        let intervalId = this.almostNowIntervalId;
-        if (intervalId === undefined) {
-            return;
-        }
-        this.almostNowIntervalId = undefined;
-        clearInterval(intervalId);
-    }
-
-    resumeSampling() {
-        if (this.almostNowIntervalId) {
-            throw new Error("already sampling");
-        }
-        this.almostNow = this.precise.now();
-        this.almostNowIntervalId = setInterval(() => {
-            if (this.almostNowIntervalId !== undefined) {
-                this.almostNow = this.precise.now();
-            }
-        }, this.updateIntervalMs);
-    }
-
-    public refreshNow(): void {
-        this.pauseSampling();
-        this.resumeSampling();
-    }
-}
-
-export const preciseClock = new HrTimeClock();
-let _approximateClock: SampledClock;
-export const approximateClock: () => Clock = () => {
-    if (_approximateClock === undefined) {
-        _approximateClock = approx(preciseClock);
-    }
-    return _approximateClock;
-}
-
-export function cleanUp() {
-    if (_approximateClock !== undefined) {
-        _approximateClock.pauseSampling();
-        _approximateClock = undefined;
-    }
-}

package/src/utils/collections.ts

@@ -1,283 +0,0 @@
-export interface KeySerializer<T> {
-    serialize(a: Record<string, unknown>): T
-}
-
-const defaultKeySerializer: KeySerializer<string> = {
-    serialize(o: Record<string, unknown>): string {
-        const order = o === undefined ? [] : Object.keys(o).sort((a, b) => a.localeCompare(b));
-        return JSON.stringify(o, order);
-    }
-}
-
-export class ObjectSet<T extends Record<string, unknown>> implements Set<T> {
-    private readonly map: Map<unknown, T> = new Map<unknown, T>();
-    private readonly serializer: KeySerializer<unknown> = defaultKeySerializer;
-
-    constructor(values?: readonly T[] | null, serializer: KeySerializer<unknown> = defaultKeySerializer) {
-        this.serializer = serializer;
-        this.map = new Map<unknown, T>((values ?? new Array<T>()).map((value) => {
-            const key: unknown = serializer.serialize(value);
-            return [key, value];
-        }));
-    }
-
-    [Symbol.iterator](): SetIterator<T> {
-        return this.values();
-    }
-
-    [Symbol.toStringTag]: string = 'ObjectSet';
-
-    *entries(): SetIterator<[T, T]> {
-        for (const value of this.values()) {
-            yield [value, value];
-        }
-    }
-
-    keys = this.values;
-
-    values(): SetIterator<T> {
-        return this.map.values();
-    }
-
-    add(value: T): this {
-        const key = this.serializer.serialize(value);
-        this.map.set(key, value);
-        return this;
-    }
-
-    clear() {
-        this.map.clear();
-    }
-
-    delete(value: T): boolean {
-        const key = this.serializer.serialize(value);
-        return this.map.delete(key);
-    }
-
-    forEach(callbackfn: (value: T, key: T, set: Set<T>) => void, thisArg?: any) {
-        for (const value of this.map.values()) {
-            callbackfn.call(thisArg, value, value, this);
-        }
-    }
-
-    has(value: T): boolean {
-        const key = this.serializer.serialize(value);
-        return this.map.has(key);
-    }
-
-    get size(): number {
-        return this.map.size;
-    }
-}
-
-export class ObjectMap<K extends Record<string, unknown>, V> implements Map<K, V> {
-    private readonly map: Map<unknown, [K, V]> = new Map<unknown, [K, V]>();
-
-    private readonly serializer: KeySerializer<unknown> = defaultKeySerializer;
-
-    constructor(entries?:[[K, V]],
-                serializer: KeySerializer<unknown> = defaultKeySerializer) {
-        this.serializer = serializer;
-        this.map = new Map<unknown, [K, V]>((entries ?? new Array<[K, V]>()).map(([key, value]) => {
-            const k: unknown = serializer.serialize(key);
-            return [k, [key, value]];
-        }));
-    }
-
-    [Symbol.iterator](): MapIterator<[K, V]> {
-        return this.entries();
-    }
-
-    [Symbol.toStringTag]: string = 'ObjectMap';
-
-
-    clear() {
-        this.map.clear();
-    }
-
-    delete(key: K): boolean {
-        return this.map.delete(this.serializer.serialize(key));
-    }
-
-    *entries(): MapIterator<[K, V]> {
-        for (const [, [key, value]] of this.map.entries()) {
-            yield [key, value];
-        }
-    }
-
-    *keys(): MapIterator<K> {
-        for (const [key,] of this.map.values()) {
-            yield key;
-        }
-    }
-
-    *values(): MapIterator<V> {
-        for (const [, value] of this.map.values()) {
-            yield value;
-        }
-    }
-
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any) {
-        for (const [,[key, value]] of this.map) {
-            callbackfn.call(thisArg, value, key, this);
-        }
-    }
-
-    get(key: K): V | undefined {
-        const result = this.map.get(this.serializer.serialize(key));
-        if (result) {
-            const [, value] = result;
-            return value;
-        }
-    }
-
-    has(key: K): boolean {
-        return this.map.has(this.serializer.serialize(key));
-    }
-
-    set(key: K, value: V): this {
-        this.map.set(this.serializer.serialize(key), [key, value]);
-        return this;
-    }
-
-    get size(): number {
-        return this.map.size;
-    }
-}
-
-export type Comparator<T> = (e1: T, e2: T) => -1 | 0 | 1;
-
-export function composeComparators<T>(...comparators: Comparator<T>[]): Comparator<T> {
-    return (e1: T, e2: T) => {
-        for (const comparator of comparators) {
-            const result = comparator(e1, e2);
-            if (result !== 0) {
-                return result;
-            }
-        }
-        return 0;
-    };
-}
-
-export function compareArrays<T>(a1: ArrayLike<T>, offset1: number, length1: number,
-                                 a2: ArrayLike<T>, offset2: number, length2: number,
-                                 comparator: Comparator<T>): ReturnType<Comparator<ArrayLike<T>>> {
-    if (a1 == a2 && offset1 == offset2 && length1 == length2)
-        return 0;
-
-    const end1 = offset1 + length1;
-    const end2 = offset2 + length2;
-    for (let i = offset1, j = offset2; i < end1 && j < end2; i++, j++)
-    {
-        const result = comparator(a1[i], a2[j]);
-        if (result !== 0) {
-            return result;
-        }
-    }
-    return length1 < length2 ? -1 : length1 === length2 ? 0 : 1;
-}
-
-export class PriorityQueue<T> {
-    readonly comparator: Comparator<T>;
-    private _count: number = 0;
-    private _items: Array<T>;
-
-    constructor(comparator: Comparator<T>, initialCapacity: number = 11) {
-        this._items = new Array<T>(initialCapacity);
-        this.comparator = comparator;
-    }
-
-    get size(): number {
-        return this._count;
-    }
-
-    dequeue(): T | undefined {
-        const result = this.peek();
-        if (result === undefined) {
-            return undefined;
-        }
-        const newCount = --this._count;
-        const lastItem = this._items[newCount];
-        this._items[newCount] = undefined as unknown as T;
-        if (newCount > 0) {
-            this.trickleDown(0, lastItem);
-        }
-        return result;
-    }
-
-    peek(): T | undefined {
-        if (this._count === 0) {
-            return undefined;
-        }
-        return this._items[0];
-    }
-
-    enqueue(item: T): void {
-        if (item === undefined) {
-            throw new Error('element is undefined');
-        }
-
-        const oldCount = this._count;
-        if (oldCount === this._items.length) {
-            this.growHeap();
-        }
-        this._count = oldCount + 1;
-        this.bubbleUp(oldCount, item);
-    }
-
-    remove(item: T): boolean {
-        const index = this._items.indexOf(item);
-        if (index === -1) {
-            return false;
-        }
-        const newCount = --this._count;
-        if (index === newCount) {
-            this._items[index] = undefined as unknown as T;
-        }
-        else {
-            const lastItem = this._items[newCount];
-            this._items[newCount] = undefined as unknown as T;
-            this.trickleDown(index, lastItem);
-            if (this._items[index] === lastItem) {
-                this.bubbleUp(index, lastItem);
-            }
-        }
-        return true;
-    }
-
-    private bubbleUp(index: number, item: T): void {
-        while (index > 0) {
-            const parentIndex = (index - 1) >> 1;
-            const parentItem = this._items[parentIndex];
-            if (this.comparator(item, parentItem) >= 0) {
-                break;
-            }
-            this._items[index] = parentItem;
-            index = parentIndex;
-        }
-        this._items[index] = item;
-    }
-
-    private trickleDown(index: number, item: T): void {
-        const middleIndex = this._count >> 1;
-        while (index < middleIndex) {
-            let childIndex = (index << 1) + 1;
-            let childItem = this._items[childIndex];
-            const rightChildIndex = childIndex + 1;
-            if (rightChildIndex < this._count && this.comparator(childItem, this._items[rightChildIndex]) > 0) {
-                childIndex = rightChildIndex;
-                childItem = this._items[rightChildIndex];
-            }
-            if (this.comparator(item, childItem) <= 0) {
-                break;
-            }
-            this._items[index] = childItem;
-            index = childIndex;
-        }
-        this._items[index] = item;
-    }
-
-    private growHeap() {
-        // do nothing for now
-    }
-}

package/src/utils/crc.ts

@@ -1,39 +0,0 @@
-import {crc32} from 'node:zlib'; // requires Node.js >=22.2 || >=20.15
-import type {ByteBuffer} from "./buffer";
-
-
-const CRC32_INIT = crc32(new Uint8Array([0xFA,0x2D, 0x55, 0xCA]));
-
-export function computeCrc32(buffer: ByteBuffer, start: number, end: number): number {
-    const savePosition = buffer.position;
-    const saveLimit = buffer.limit;
-    buffer.limit = end;
-    buffer.position = start;
-
-    const data = new Uint8Array(end - start);
-    buffer.getUint8Array(data);
-    const crc = crc32(data, CRC32_INIT);
-
-    buffer.limit = saveLimit;
-    buffer.position = savePosition;
-
-    return 0xffffffff & crc;
-}
-
-const CRC24_INIT = 0x875060;
-const CRC24_POLY = 0x1974F0B;
-
-export function crc24(bytes: bigint, length: number): number {
-    let crc: number = CRC24_INIT;
-    while (length-- > 0) {
-        crc ^= Number((bytes & 0xffn) << 16n); // no sign will be lost
-        bytes >>= 8n;
-        for (let i = 0; i < 8; i++) {
-            crc <<= 1;
-            if ((crc & 0x1000000) !== 0) {
-                crc ^= CRC24_POLY;
-            }
-        }
-    }
-    return crc;
-}

package/src/utils/internal/IpAddressUtil.ts

@@ -1,161 +0,0 @@
-const DOT = '.'.charCodeAt(0);
-const INET_ADDRESS_V4_SIZE = 4;
-const INET_ADDRESS_V6_SIZE = 16;
-const BYTE_SIZE = 2; // 8 bits in hex
-const COLON = ':'.charCodeAt(0);
-
-export function textToNumericFormatV4(address: string): Uint8Array {
-    const result = new Uint8Array(4);
-    const len = address.length;
-    if (len == 0 || len > 15) {
-        return;
-    }
-
-    let currentValue = 0;
-    let currentByte = 0;
-    let newByte = true;
-    for (let i = 0; i < len; i++) {
-        const ch = address.charCodeAt(i);
-        if (ch === DOT) {
-            if (newByte || currentValue < 0 || currentValue > 0xff || currentByte > 3) {
-                return;
-            }
-            result[currentByte++] = currentValue & 0xff;
-            currentValue = 0;
-            newByte = true;
-        } else {
-            const digit = ch - 48;
-            if (digit < 0) {
-                return;
-            }
-            currentValue *= 10;
-            currentValue += digit;
-            newByte = false;
-        }
-    }
-    if (newByte || currentValue < 0 || currentValue >= (1 << ((4 - currentByte) * 8))) {
-        return;
-    }
-
-    switch (currentByte) {
-        case 0:
-            result[0] = (currentValue >> 24) & 0xff;
-        //fall through
-        case 1:
-            result[1] = (currentValue >> 16) & 0xff;
-        //fall through
-        case 2:
-            result[2] = (currentValue >> 8) & 0xff;
-        //fall through
-        case 3:
-            result[3] = (currentValue >> 0) & 0xff;
-    }
-    return result;
-}
-
-export function textToNumericFormatV6(address: string): Uint8Array {
-    if (address.length < 2) {
-        return;
-    }
-
-    // let colonp: number;
-    // let char: number;
-    // let saw_xdigit: boolean;
-    // let val: number;
-    // const dst = new Uint8Array(INET_ADDRESS_V6_SIZE);
-    //
-    // const srcb_length = address.length;
-    // const pc = src.indexOf('%');
-    // if (pc === srcb_length -1) {
-    //     return;
-    // }
-    //
-    // colonp = -1;
-    //
-    // let i = 0, j = 0;
-    //     /* Leading :: requires some special handling. */
-    //     if (address.charAt(i) === ':')
-    //         if (address.charAt(++i) !== ':')
-    //             return;
-    //     curtok = i;
-    //     saw_xdigit = false;
-    //     val = 0;
-    //     while (i < srcb_length) {
-    //         const ch = address.charCodeAt(i++);
-    //         const chval = ch - 48;
-    //         if (chval !== -1) {
-    //             val <<= 4;
-    //             val |= chval;
-    //             if (val > 0xffff)
-    //                 return;
-    //             saw_xdigit = true;
-    //             continue;
-    //         }
-    //         if (ch == ':') {
-    //             curtok = i;
-    //             if (!saw_xdigit) {
-    //                 if (colonp != -1)
-    //                     return null;
-    //                 colonp = j;
-    //                 continue;
-    //             } else if (i == srcb_length) {
-    //                 return null;
-    //             }
-    //             if (j + INT16SZ > INADDR16SZ)
-    //                 return null;
-    //             dst[j++] = (byte) ((val >> 8) & 0xff);
-    //             dst[j++] = (byte) (val & 0xff);
-    //             saw_xdigit = false;
-    //             val = 0;
-    //             continue;
-    //         }
-    //         if (ch == '.' && ((j + BYTE_SIZE) <= INET_ADDRESS_V6_SIZE)) {
-    //             const ia4 = address.substring(curtok, srcb_length);
-    //             /* check this IPv4 address has 3 dots, ie. A.B.C.D */
-    //             let dot_count = 0, index=0;
-    //             while ((index = ia4.indexOf ('.', index)) != -1) {
-    //                 dot_count ++;
-    //                 index ++;
-    //             }
-    //             if (dot_count != 3) {
-    //                 return null;
-    //             }
-    //             const v4addr = textToNumericFormatV4(ia4);
-    //             if (v4addr == null) {
-    //                 return null;
-    //             }
-    //             for (let k = 0; k < INET_ADDRESS_V4_SIZE; k++) {
-    //                 dst[j++] = v4addr[k];
-    //             }
-    //             saw_xdigit = false;
-    //             break;  /* '\0' was seen by inet_pton4(). */
-    //         }
-    //         return null;
-    //     }
-    //     if (saw_xdigit) {
-    //         if (j + INT16SZ > INADDR16SZ)
-    //             return null;
-    //         dst[j++] = (byte) ((val >> 8) & 0xff);
-    //         dst[j++] = (byte) (val & 0xff);
-    //     }
-    //
-    //     if (colonp != -1) {
-    //         const n = j - colonp;
-    //
-    //         if (j == INADDR16SZ)
-    //             return null;
-    //         for (i = 1; i <= n; i++) {
-    //             dst[INADDR16SZ - i] = dst[colonp + n - i];
-    //             dst[colonp + n - i] = 0;
-    //         }
-    //         j = INADDR16SZ;
-    //     }
-    //     if (j != INADDR16SZ)
-    //         return null;
-    //     const newdst = convertFromIPv4MappedAddress(dst);
-    //     if (newdst != null) {
-    //         return newdst;
-    //     } else {
-    //         return dst;
-    //     }
-}

package/src/utils/memory/BufferPools.ts

@@ -1,40 +0,0 @@
-import {allocate, type ByteBuffer} from '../buffer.ts';
-
-class BufferPool {
-
-    protected readonly name: string;
-    private readonly memoryUsageThreshold: number;
-    private overflowMemoryUsage: number = 0;
-    private readonly recyclePartially: boolean;
-
-    constructor(name: string, memoryUsageThreshold: number, recyclePartially: boolean = false) {
-        this.name = name;
-        this.memoryUsageThreshold = memoryUsageThreshold;
-        this.recyclePartially = recyclePartially;
-    }
-
-    private allocateBuf(size: number): ByteBuffer {
-        this.updateOverflowMemoryUsage(size);
-        return allocate(size);
-    }
-
-    public getAtLeast(size: number): ByteBuffer {
-        return this.allocateBuf(size);
-    }
-
-    public put(buffer: ByteBuffer) {
-        this.updateOverflowMemoryUsage(-buffer.capacity);
-    }
-
-    private updateOverflowMemoryUsage(size: number) {
-        this.overflowMemoryUsage += size;
-    }
-}
-
-const NETWORKING_POOL = new BufferPool("networking", 1024 * 1024 * 10); // 10 MB
-
-export type {BufferPool};
-
-export function forNetworking(): BufferPool {
-    return NETWORKING_POOL;
-}