harmony-erlpack 0.0.1

package/src/encode.ts

@@ -0,0 +1,170 @@
+import {erlTypes, version} from "./erltype.js";
+
+class ByteLayer {
+	private buffer = new ArrayBuffer(1 << 6);
+	private view = new DataView(this.buffer);
+	private index: number = 0;
+	private getSpace(len: number) {
+		if (this.index + len >= this.buffer.byteLength) {
+			let llen = this.buffer.byteLength;
+			while (this.index + len >= llen) llen *= 2;
+			this.buffer = this.buffer.transfer(llen);
+			this.view = new DataView(this.buffer);
+		}
+		const old = this.index;
+		this.index += len;
+		return old;
+	}
+	appendByte(num: number) {
+		const i = this.getSpace(1);
+		this.view.setInt8(i, num);
+	}
+	append32IntDelayed() {
+		const i = this.getSpace(4);
+		return (num: number) => {
+			this.view.setInt32(i, num);
+		};
+	}
+	append32Int(num: number) {
+		const i = this.getSpace(4);
+		this.view.setInt32(i, num);
+	}
+	append16Int(num: number) {
+		const i = this.getSpace(2);
+		this.view.setInt16(i, num);
+	}
+	appendDouble(num: number) {
+		const i = this.getSpace(8);
+		this.view.setFloat64(i, num);
+	}
+	getBuffer(len: number) {
+		const i = this.getSpace(len);
+		return {
+			buff: new Uint8Array(this.buffer, i),
+			ret: (num: number) => {
+				this.index -= num;
+			},
+		};
+	}
+	appendBuffer(buf: Uint8Array | number[]) {
+		const i = this.getSpace(buf.length);
+		//console.error(i, this.index, this.buffer.byteLength);
+		new Uint8Array(this.buffer).set(buf, i);
+	}
+	toBuffer() {
+		return this.buffer.transfer(this.index);
+	}
+}
+const encoder = new TextEncoder();
+const preAtoms = new Map<string, Uint8Array>();
+
+export function pack(obj: unknown) {
+	const layer = new ByteLayer();
+	const strMap = new Map<string, Uint8Array>();
+
+	function appendAtom(str: string) {
+		const buf = preAtoms.get(str) ?? encoder.encode(str);
+		if (!preAtoms.has(str)) preAtoms.set(str, buf);
+		layer.appendByte(erlTypes.sAtom);
+		layer.appendByte(buf.length);
+		layer.appendBuffer(buf);
+	}
+	function layBigint(d: bigint) {
+		const bytes = [] as number[];
+		const sign = d < 0n;
+		d = sign ? d * -1n : d;
+		while (d > 0n) {
+			bytes.push(Number(d & 0xffn));
+			d >>= 8n;
+		}
+		if (bytes.length < 255) {
+			layer.appendByte(erlTypes.sbigint);
+			layer.appendByte(bytes.length);
+			layer.appendByte(+sign);
+			layer.appendBuffer(bytes);
+		}
+	}
+	layer.appendByte(version);
+	function packObj(obj: unknown) {
+		switch (typeof obj) {
+			case "number": {
+				if (Number.isInteger(obj) && obj < 2 ** 32 && obj >= -(2 ** 31)) {
+					if (obj > 0 && obj < 256) {
+						layer.appendByte(erlTypes.u8);
+						layer.appendByte(obj);
+					} else if (obj < 2 ** 31 && obj >= -(2 ** 31)) {
+						layer.appendByte(erlTypes.i32);
+						layer.append32Int(obj);
+					} else {
+						layBigint(BigInt(obj));
+					}
+				} else {
+					layer.appendByte(erlTypes.double);
+					layer.appendDouble(obj);
+				}
+				break;
+			}
+			case "undefined": {
+				appendAtom("nil");
+				break;
+			}
+			case "boolean": {
+				appendAtom(obj + "");
+				break;
+			}
+			case "string": {
+				if (obj.length < 100) {
+					const buf = strMap.get(obj) ?? encoder.encode(obj);
+					strMap.set(obj, buf);
+					layer.appendByte(erlTypes.bin);
+					layer.append32Int(buf.length);
+					layer.appendBuffer(buf);
+				} else {
+					layer.appendByte(erlTypes.bin);
+					const len = layer.append32IntDelayed();
+					const size = obj.length * 3;
+					const {buff, ret} = layer.getBuffer(size);
+					const {written} = encoder.encodeInto(obj, buff);
+					ret(size - written);
+					len(written);
+				}
+
+				break;
+			}
+			case "object": {
+				if (obj instanceof Array) {
+					layer.appendByte(erlTypes.array);
+					layer.append32Int(obj.length);
+					for (const item of obj) {
+						packObj(item);
+					}
+					//Leaving this off will make @yukikaze-bot/erlpack segfault
+					layer.appendByte(erlTypes.endList);
+				} else if (obj === null) {
+					appendAtom("nil");
+				} else {
+					layer.appendByte(erlTypes.object);
+					const pairs = Object.entries(obj);
+					layer.append32Int(pairs.length);
+					for (const [key, value] of pairs) {
+						if (typeof value === "function" || typeof value === "symbol") continue;
+						packObj(key);
+						packObj(value);
+					}
+				}
+				break;
+			}
+			case "bigint": {
+				layBigint(obj);
+				break;
+			}
+			default: {
+				const type = typeof obj;
+				throw new Error(`unsupported type: ${type}`);
+			}
+		}
+	}
+
+	packObj(obj);
+	return layer.toBuffer();
+}

package/src/erltype.ts

@@ -0,0 +1,14 @@
+export const version = 131;
+export const enum erlTypes {
+	u8 = 97,
+	sAtom = 115,
+	i32 = 98,
+	double = 70,
+	sbigint = 110,
+	lbigint = 111,
+	string16 = 107,
+	bin = 109,
+	array = 108,
+	endList = 106,
+	object = 116,
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./encode.js";
+export * from "./decode.js";