stagelinq 1.0.0

package/utils/WriteContext.ts

@@ -0,0 +1,105 @@
+'use strict';
+const assert = require('assert');
+import { Context } from './Context';
+
+interface WriteContextConstructOptions {
+	size?: number;
+	autoGrow?: boolean;
+	littleEndian?: boolean;
+}
+
+export class WriteContext extends Context {
+	autoGrow: boolean;
+
+	constructor(p_options?: WriteContextConstructOptions) {
+		const buffer = new ArrayBuffer(p_options && p_options.size > 0 ? p_options.size : 128);
+		super(buffer, !p_options ? false : !!p_options.littleEndian);
+		this.autoGrow = !p_options || (p_options.autoGrow ? !!p_options.autoGrow : true);
+	}
+
+	getBuffer(): Buffer {
+		const newBuf = Buffer.from(this.buffer, 0, this.pos);
+		return newBuf;
+	}
+
+	sizeLeft(): number {
+		return this.buffer.byteLength - this.pos;
+	}
+
+	checkSize(p_size: number): void {
+		while (true) {
+			const diff = this.sizeLeft() - p_size;
+			if (diff >= 0) {
+				break;
+			}
+			if (this.autoGrow) {
+				this.resize();
+				continue;
+			}
+			assert.fail(`Writing ${-diff} bytes OOB of fixed size buffer`);
+		}
+	}
+
+	resize(): void {
+		assert(this.autoGrow);
+		const size = this.buffer.byteLength;
+		const newBuffer = new ArrayBuffer(size * 2);
+		new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+		this.buffer = newBuffer;
+	}
+
+	write(p_buffer: Uint8Array, p_bytes: number = -1): number {
+		if (p_bytes <= 0) {
+			p_bytes = p_buffer.byteLength;
+		}
+
+		this.checkSize(p_bytes);
+
+		new Uint8Array(this.buffer).set(p_buffer, this.pos);
+		this.pos += p_bytes;
+		return p_bytes;
+	}
+
+	writeFixedSizedString(p_string: string): number {
+		for (let i = 0; i < p_string.length; ++i) {
+			this.writeUInt8(p_string.charCodeAt(i));
+		}
+		return p_string.length;
+	}
+
+	writeNetworkStringUTF16(p_string: string): number {
+		let written = this.writeUInt32(p_string.length * 2);
+		for (let i = 0; i < p_string.length; ++i) {
+			written += this.writeUInt16(p_string.charCodeAt(i));
+		}
+		return written;
+	}
+
+	writeUInt64(p_value: bigint): number {
+		this.checkSize(8);
+		new DataView(this.buffer).setBigUint64(this.pos, p_value, this.littleEndian);
+		this.pos += 8;
+		return 8;
+	}
+
+	writeUInt32(p_value: number): number {
+		this.checkSize(4);
+		new DataView(this.buffer).setUint32(this.pos, p_value, this.littleEndian);
+		this.pos += 4;
+		return 4;
+	}
+
+	writeUInt16(p_value: number): number {
+		this.checkSize(2);
+		new DataView(this.buffer).setUint16(this.pos, p_value, this.littleEndian);
+		this.pos += 2;
+		return 2;
+	}
+
+	writeUInt8(p_value: number): number {
+		this.checkSize(1);
+		new DataView(this.buffer).setUint8(this.pos, p_value);
+		this.pos += 1;
+		return 1;
+	}
+}

package/utils/getTempFilePath.ts

@@ -0,0 +1,23 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+/**
+ * Recursively create a directory under the OS's temp path.
+ *
+ * @param p_path Directory to create including filename
+ * @returns Absolute path
+ */
+export function getTempFilePath(p_path: string) {
+	const tmpPath = `/${os.tmpdir()}/localdb/${p_path}`;
+	let paths = tmpPath.split(/[/\\]/).filter((e) => e.length > 0);
+	const isFolder = p_path.endsWith('/') || p_path.endsWith('\\');
+	let filename = '';
+	if (isFolder === false) {
+		filename = paths[paths.length - 1];
+		paths.pop();
+	}
+	const newPath = paths.join('/');
+	fs.mkdirSync(path.resolve('/', newPath), { recursive: true });
+	return path.resolve('/', newPath, filename);
+}

package/utils/hex.ts

@@ -0,0 +1,62 @@
+// Based on https://www.npmjs.com/package/hex
+const zero = function (n: number, max: number) {
+	let str = n.toString(16).toUpperCase();
+	while (str.length < max) {
+		str = '0' + str;
+	}
+	return str;
+};
+
+export function hex(p_buffer: Uint8Array, p_columns: number = 16) {
+	const rows = Math.ceil(p_buffer.length / p_columns);
+	const last = p_buffer.length % p_columns || p_columns;
+	let offsetLength = p_buffer.length.toString(16).length;
+	if (offsetLength < 6) offsetLength = 6;
+
+	let str = 'Offset';
+	while (str.length < offsetLength) {
+		str += ' ';
+	}
+
+	str = '\u001b[36m' + str + '  ';
+
+	for (let i = 0; i < p_columns; i++) {
+		str += ' ' + zero(i, 2);
+	}
+
+	str += '\u001b[0m';
+	if (p_buffer.length) str += '\n';
+
+	let b = 0;
+	let lastBytes: number;
+	let lastSpaces: number;
+	let v: number;
+
+	for (let i = 0; i < rows; i++) {
+		str += '\u001b[36m' + zero(b, offsetLength) + '\u001b[0m  ';
+		lastBytes = i === rows - 1 ? last : p_columns;
+		lastSpaces = p_columns - lastBytes;
+
+		for (let j = 0; j < lastBytes; j++) {
+			str += ' ' + zero(p_buffer[b], 2);
+			b++;
+		}
+
+		for (let j = 0; j < lastSpaces; j++) {
+			str += '   ';
+		}
+
+		b -= lastBytes;
+		str += '   ';
+
+		for (let j = 0; j < lastBytes; j++) {
+			v = p_buffer[b];
+			str += (v > 31 && v < 127) || v > 159 ? String.fromCharCode(v) : '.';
+			b++;
+		}
+
+		str += '\n';
+	}
+
+	process.stdout.write(str);
+}

package/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './Context';
+export * from './hex';
+export * from './ReadContext';
+export * from './sleep';
+export * from './tcp';
+export * from './WriteContext';

package/utils/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(p_ms: number) {
+	return new Promise((resolve) => setTimeout(resolve, p_ms));
+}

package/utils/tcp.ts

@@ -0,0 +1,17 @@
+import { Socket as TCPSocket } from 'net';
+import { PromiseSocket } from 'promise-socket';
+import { CONNECT_TIMEOUT } from '../types';
+import { Logger } from '../LogEmitter';
+
+export type Connection = PromiseSocket<TCPSocket>;
+
+export async function connect(p_ip: string, p_port: number): Promise<Connection> {
+	const socket = new TCPSocket();
+	socket.setTimeout(CONNECT_TIMEOUT);
+	const promiseSocket = new PromiseSocket(socket);
+	await promiseSocket.connect(p_port, p_ip).catch((e) => {
+		throw new Error(`Failed to connect to '${p_ip}:${p_port}': ${e}`);
+	});
+	Logger.debug(`TCP connection to '${p_ip}:${p_port}' local port: ${promiseSocket.socket.localPort}`);
+	return promiseSocket;
+}