structom 0.0.1

package/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "structom",
+	"version": "0.0.1",
+	"description": "new generation of reactivity and speed",
+	"author": "aliibrahim123",
+	"type": "module",
+	"homepage": "https://aliibrahim123.github.io/structom/",
+	"bugs": {
+		"url": "https://github.com/aliibrahim123/structom/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/aliibrahim123/structom.git"
+	},
+	"license": "MIT"
+}

package/src/any.ts

@@ -0,0 +1,145 @@
+import { decode_i16, decode_i32, decode_i64, decode_i8, decode_u16, decode_u32, decode_u64, decode_u8, encode_u8, type Buffer, type Cursor } from "./buf.ts";
+import { decode_bool, decode_str, decode_arr, decode_map, encode_bool, encode_str, encode_arr, encode_map } from "./general.ts";
+import type { Value } from "./index.ts";
+import { decode_f32, decode_f64, decode_vint, decode_vuint, encode_f64, encode_vint, encode_vuint } from "./number.ts";
+import { decode_dur, decode_inst, decode_instN, decode_uuid, encode_dur, encode_inst, encode_uuid } from "./rich.ts";
+
+const any_typeid = 0x01;
+const bool_typeid = 0x08;
+const u8_typeid = 0x10;
+const u16_typeid = 0x11;
+const u32_typeid = 0x12;
+const u64_typeid = 0x13;
+const i8_typeid = 0x14;
+const i16_typeid = 0x15;
+const i32_typeid = 0x16;
+const i64_typeid = 0x17;
+const f32_typeid = 0x18;
+const f64_typeid = 0x19;
+const vuint_typeid = 0x1c;
+const vint_typeid = 0x1d;
+const str_typeid = 0x20;
+const arr_typeid = 0x22;
+const map_typeid = 0x23;
+const inst_typeid = 0x30;
+const instn_typeid = 0x31;
+const dur_typeid = 0x32;
+const uuid_typeid = 0x33;
+
+function decode_value(buf: Buffer, typeid: number, cur: Cursor): Value {
+	switch (typeid) {
+		case any_typeid: return decode_any(buf, cur); 
+		case bool_typeid: return decode_bool(buf, cur);
+
+		case u8_typeid:  return decode_u8(buf, cur);
+		case u16_typeid: return decode_u16(buf, cur);
+		case u32_typeid: return decode_u32(buf, cur);
+		case u64_typeid: return decode_u64(buf, cur);
+
+		case i8_typeid:  return decode_i8(buf, cur);
+		case i16_typeid: return decode_i16(buf, cur);
+		case i32_typeid: return decode_i32(buf, cur);
+		case i64_typeid: return decode_i64(buf, cur);
+
+		case f32_typeid: return decode_f32(buf, cur);
+		case f64_typeid: return decode_f64(buf, cur);
+
+		case vuint_typeid: return decode_vuint(buf, cur);
+		case vint_typeid: return decode_vint(buf, cur);
+
+		case str_typeid: return decode_str(buf, cur);
+		case inst_typeid: return decode_inst(buf, cur);
+		case instn_typeid: return decode_instN(buf, cur);
+		case dur_typeid: return decode_dur(buf, cur);
+		case uuid_typeid: return decode_uuid(buf, cur);
+
+		case arr_typeid: {
+			let item_id = decode_u8(buf, cur);	
+			return decode_arr(buf, cur, (buf, cur) => decode_value(buf, item_id, cur))
+		}
+		case map_typeid: {
+			let key_id = decode_u8(buf, cur);
+			let value_id = decode_u8(buf, cur);
+			return decode_map(buf, cur, 
+				(buf, cur) => decode_value(buf, key_id, cur), 
+				(buf, cur) => decode_value(buf, value_id, cur)
+			)
+		}
+	}
+	return undefined as any
+}
+
+export function decode_any (buf: Buffer, cur: Cursor): Value {
+	return decode_value(buf, decode_u8(buf, cur), cur);
+}
+
+function resolve_typeid(value: Value): number {
+	switch (typeof(value)) {
+		case 'boolean': return bool_typeid;
+		case 'number': return Number.isInteger(value) ? vint_typeid : f64_typeid
+		case 'bigint': return vint_typeid;
+		case 'string': return str_typeid
+	}
+
+	if (value instanceof Date) return inst_typeid;
+	if ('type' in value) switch (value.type) {
+		case 'dur': return dur_typeid;
+		case 'uuid': return uuid_typeid;
+	}
+
+	if (Array.isArray(value)) return arr_typeid;
+	return map_typeid
+}
+function encode_value(buf: Buffer, value: Value, typeid: number): void {
+	switch (typeid) {
+		case any_typeid: return encode_any(buf, value);
+		case bool_typeid: return encode_bool(buf, value as any);
+		case vint_typeid: return encode_vint(buf, value as any);
+		case f64_typeid: return encode_f64(buf, value as any);
+		case str_typeid: return encode_str(buf, value as any);
+		case inst_typeid: return encode_inst(buf, value as any);
+		case dur_typeid: return encode_dur(buf, value as any);
+		case uuid_typeid: return encode_uuid(buf, value as any);
+	}
+}
+export function encode_any (buf: Buffer, value: Value): void {
+	let typeid = resolve_typeid(value);
+	encode_u8(buf, typeid);
+
+	if (typeid !== arr_typeid && typeid !== map_typeid) 
+		return encode_value(buf, value, typeid);
+	
+	if (Array.isArray(value)) {
+		let item_id = value.length === 0 ? any_typeid : resolve_typeid(value[0]);
+		for (let v of value) if (resolve_typeid(v) !== item_id) {
+			item_id = any_typeid;
+			break
+		}
+		if (item_id === arr_typeid || item_id === map_typeid) item_id = any_typeid;
+		encode_u8(buf, item_id);
+		return encode_arr(buf, value, (buf, v) => encode_value(buf, v, item_id));
+	}
+
+	if (value instanceof Map) {
+		let entry = value.entries().next().value;
+		let key_id = entry === undefined ? any_typeid : resolve_typeid(entry?.[0] as any);
+		let value_id = entry === undefined ? any_typeid : resolve_typeid(entry?.[1] as any);
+
+		for (let [k, _] of value) if (resolve_typeid(k) !== key_id) {
+			key_id = any_typeid;
+			break
+		}
+		for (let [_, v] of value) if (resolve_typeid(v) !== value_id) {
+			value_id = any_typeid;
+			break
+		}
+		if (value_id === arr_typeid || value_id === map_typeid) value_id = any_typeid;
+
+		encode_u8(buf, key_id);
+		encode_u8(buf, value_id);
+		return encode_map(buf, value, 
+			(buf, k) => encode_value(buf, k, key_id), 
+			(buf, v) => encode_value(buf, v, value_id)
+		)
+	}
+}

package/src/buf.ts

@@ -0,0 +1,116 @@
+export interface Buffer {
+	buf: Uint8Array,
+	view: DataView
+	pos: number
+}
+
+export interface Cursor {
+	pos: number
+}
+
+export function reserve(buf: Buffer, add_size: number) {
+	let old_size = buf.buf.length 
+	if (buf.pos + add_size > old_size) {
+		let new_size = old_size > 2 ** 20 ? old_size + 2 ** 10 : old_size * 2;
+		if (new_size < buf.pos + add_size) new_size = buf.pos + add_size;
+		let new_buf = new Uint8Array(new_size);
+		new_buf.set(buf.buf);
+		buf.buf = new_buf;
+		buf.view = new DataView(new_buf.buffer)
+	}
+}
+
+export function encode_u8(buf: Buffer, value: number) {
+	reserve(buf, 1);
+	buf.buf[buf.pos] = value;
+	buf.pos += 1;
+}
+export function encode_u16(buf: Buffer, value: number) {
+	reserve(buf, 2);
+	buf.view.setUint16(buf.pos, value, true);
+	buf.pos += 2;
+}
+export function encode_u32(buf: Buffer, value: number) {
+	reserve(buf, 4);
+	buf.view.setUint32(buf.pos, value, true);
+	buf.pos += 4;
+}
+export function encode_u64(buf: Buffer, value: bigint) {
+	reserve(buf, 8);
+	buf.view.setBigUint64(buf.pos, value, true);
+	buf.pos += 8;
+}
+
+export function encode_i8(buf: Buffer, value: number) {
+	reserve(buf, 1);
+	buf.view.setInt8(buf.pos, value);
+	buf.pos += 1;
+}
+export function encode_i16(buf: Buffer, value: number) {
+	reserve(buf, 2);
+	buf.view.setInt16(buf.pos, value, true);
+	buf.pos += 2;
+}
+export function encode_i32(buf: Buffer, value: number) {
+	reserve(buf, 4);
+	buf.view.setInt32(buf.pos, value, true);
+	buf.pos += 4;
+}
+export function encode_i64(buf: Buffer, value: bigint) {
+	reserve(buf, 8);
+	buf.view.setBigInt64(buf.pos, value, true);
+	buf.pos += 8;
+}
+
+export function decode_u8(buf: Buffer, cur: Cursor) {
+	let res = buf.buf[cur.pos];
+	cur.pos += 1;
+	return res;
+}
+export function decode_u16(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getUint16(cur.pos, true);
+	cur.pos += 2;
+	return res;
+}
+export function decode_u32(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getUint32(cur.pos, true);
+	cur.pos += 4;
+	return res;
+}
+export function decode_u64(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getBigUint64(cur.pos, true);
+	cur.pos += 8;
+	return res;
+}
+
+export function decode_i8(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getInt8(cur.pos);
+	cur.pos += 1;
+	return res;
+}
+export function decode_i16(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getInt16(cur.pos, true);
+	cur.pos += 2;
+	return res;
+}
+export function decode_i32(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getInt32(cur.pos, true);
+	cur.pos += 4;
+	return res;
+}
+export function decode_i64(buf: Buffer, cur: Cursor) {
+	let res = buf.view.getBigInt64(cur.pos, true);
+	cur.pos += 8;
+	return res;
+}
+
+export function encode_u8_arr(buf: Buffer, value: ArrayLike<number>) {
+	reserve(buf, value.length);
+	buf.buf.set(value, buf.pos);
+	buf.pos += value.length;
+}
+export function decode_u8_arr(buf: Buffer, size: number, cur: Cursor) {
+	let res = buf.buf.slice(cur.pos, cur.pos + size);
+	cur.pos += size;
+	return res
+}

package/src/general.ts

@@ -0,0 +1,90 @@
+import { decode_u8, decode_u8_arr, encode_u8, encode_u8_arr, reserve, type Buffer, type Cursor } from "./buf.ts";
+import { decode_vuint, encode_vuint } from "./number.ts";
+
+export function encode_bool(buf: Buffer, value: boolean) {
+	encode_u8(buf, value === true ? 1 : 0)
+}
+export function decode_bool(buf: Buffer, cur: Cursor) {
+	return decode_u8(buf, cur) !== 0
+}
+
+let TextEnc = new TextEncoder(); 
+export function encode_str(buf: Buffer, value: string) {
+	let res = TextEnc.encode(value);
+	encode_vuint(buf, res.length);
+	encode_u8_arr(buf, res);
+}
+
+let TextDec = new TextDecoder('utf-8');
+export function decode_str (buf: Buffer, cur: Cursor) {
+	let size = decode_vuint(buf, cur) as number;
+	return TextDec.decode(decode_u8_arr(buf, size, cur));
+}
+
+type Encoder <T> = (buf: Buffer, value: T) => void;
+type Decoder <T> = (buf: Buffer, cur: Cursor) => T;
+
+export function encode_arr<T> (buf: Buffer, value: T[], item_fn: Encoder<T>, in_field = false) {
+	if (!in_field) 
+		encode_vuint(buf, value.length);
+	for (let val of value) 
+		item_fn(buf, val);
+}
+export function decode_arr<T> (buf: Buffer, cur: Cursor, item_fn: Decoder<T>, in_field = false) {
+	let len = decode_vuint(buf, cur) as number;
+	if (in_field) {
+		let start_ind = cur.pos;
+		let arr: T[] = [];
+		while (cur.pos < start_ind + len)
+			arr.push(item_fn(buf, cur));
+		return arr
+	} else {
+		let arr: T[] = [];
+		for (let i = 0; i < len; i++) 
+			arr.push(item_fn(buf, cur));
+		return arr
+	}
+}
+
+export function encode_map<K, V> (
+	buf: Buffer, value: Map<K, V>, key_fn: Encoder<K>, val_fn: Encoder<V>, 
+	in_field = false
+) {
+	if (!in_field) 
+		encode_vuint(buf, value.size);
+	for (let [k, v] of value) {
+		key_fn(buf, k);
+		val_fn(buf, v);
+	}
+}
+export function decode_map<K, V> (
+	buf: Buffer, cur: Cursor, key_fn: Decoder<K>, val_fn: Decoder<V>, 
+	in_field = false
+) {
+	let len = decode_vuint(buf, cur) as number;
+	if (in_field) {
+		let start_ind = cur.pos;
+		let map = new Map<K, V>();
+		while (cur.pos < start_ind + len) 
+			map.set(key_fn(buf, cur), val_fn(buf, cur));
+		return map
+	} else {
+		let map = new Map<K, V>();
+		for (let i = 0; i < len; i++) {
+			map.set(key_fn(buf, cur), val_fn(buf, cur));}
+		return map
+	}
+}
+
+export function skip_field (buf: Buffer, cur: Cursor, header: number) {
+	switch (header & 0b111) {
+		case 0b000: cur.pos += 1; break;
+		case 0b001: cur.pos += 2; break;
+		case 0b010: cur.pos += 4; break;
+		case 0b011: cur.pos += 8; break;
+		// decode vuint and ignore
+		case 0b100: decode_vuint(buf, cur); break;
+		// len field is encoded
+		case 0b101: cur.pos += decode_vuint(buf, cur) as number;
+	}
+}

package/src/index.ts

@@ -0,0 +1,40 @@
+import { decode_any, encode_any } from "./any.ts";
+import { decode_u8, encode_u8, type Buffer, type Cursor } from "./buf.ts";
+
+export interface UUID {
+	type: 'uuid',
+	value: Uint8Array
+};
+export interface Dur {
+	type: 'dur',
+	value: bigint
+}
+export type Value = 
+	boolean | number | string | bigint | Date | UUID | Dur | Array<Value> | Map<Value, Value>;
+
+export function encode(value: Value) {
+	let _buf = new Uint8Array(256);
+	let buf: Buffer = { buf: _buf, pos: 0, view: new DataView(_buf.buffer) };
+	encode_u8(buf, 0);
+	encode_any(buf, value);
+	return buf.buf.slice(0, buf.pos);
+}
+
+export function decode(data: ArrayBuffer) {
+	let buf: Buffer = { buf: new Uint8Array(data), pos: 0, view: new DataView(data) };
+	let cur: Cursor = { pos: 0 };
+	if (decode_u8(buf, cur) !== 0) return;
+	let value = decode_any(buf, cur);
+	if (cur.pos !== data.byteLength) return;
+	return value;
+}
+
+export * from './any.ts';
+export * from './general.ts';
+export * from './number.ts';
+export * from './rich.ts';
+export { 
+	decode_i8, decode_i16, decode_i32, decode_i64, decode_u8, decode_u16, decode_u32, decode_u64, 
+	decode_u8_arr, encode_i8, encode_i16, encode_i32, encode_i64, encode_u8, encode_u16, encode_u32, 
+	encode_u64, encode_u8_arr 
+} from './buf.ts';

package/src/number.ts

@@ -0,0 +1,166 @@
+import { decode_u8, encode_u8, reserve, type Buffer, type Cursor } from "./buf.ts";
+
+export function encode_f32 (buf: Buffer, value: number) {
+	reserve(buf, 4);
+	buf.view.setFloat32(buf.pos, value, true);
+	buf.pos += 4;
+}
+export function encode_f64 (buf: Buffer, value: number) {
+	reserve(buf, 8);
+	buf.view.setFloat64(buf.pos, value, true);
+	buf.pos += 8;
+}
+
+export function decode_f32 (buf: Buffer, cur: Cursor) {
+	let res = buf.view.getFloat32(cur.pos, true);
+	cur.pos += 4;
+	return res
+}
+export function decode_f64 (buf: Buffer, cur: Cursor) {
+	let res = buf.view.getFloat64(cur.pos, true);
+	cur.pos += 8;
+	return res
+}
+
+export function encode_vuint(buf: Buffer, value: number | bigint) {
+	let cond = true;
+
+	if (typeof(value) === 'number' && Math.abs(value) < 2 ** 31) {
+		// while there is input
+		while (cond) {
+			// extract least significant 7 bits
+			let byte = value & 0b0111_1111;
+			// shift to next section
+			value >>= 7;
+			// add continuation bit (0 = end byte)
+			encode_u8(buf, value == 0 ? byte : byte | 0b1000_0000 );
+
+			cond = value != 0;
+		}
+	} else {
+		value = BigInt(value);
+		// while there is input
+		while (cond) {
+			// extract least significant 7 bits
+			let byte = Number(value & 0b0111_1111n);
+			// shift to next section
+			value >>= 7n;
+			// add continuation bit (0 = end byte)
+			encode_u8(buf, value == 0n ? byte : byte | 0b1000_0000 );
+
+			cond = value != 0n;
+		}
+	}
+}
+export function encode_vint(buf: Buffer, value: number | bigint) {
+	let cond = true;
+
+	if (typeof(value) === 'number' && Math.abs(value) < 2 ** 31) {
+		// while there is input
+		while (cond) {
+			// extract least significant 7 bits
+			let byte = value & 0b0111_1111;
+			// shift to next section
+			value >>= 7;
+			// ensure at least 1 sign bit is encoded (0 for positive and 1 for negative)
+			let sign_bit = byte & 0b0100_0000;
+			if ((value == 0 && sign_bit == 0) || (value == -1 && sign_bit != 0))
+				cond = false;
+			// add continuation bit (0 = end byte)
+			else byte |= 0b1000_0000;
+			// add continuation bit (0 = end byte)
+			encode_u8(buf, byte);
+		}
+	} else {
+		value = BigInt(value);
+		// while there is input
+		while (cond) {
+			// extract least significant 7 bits
+			let byte = Number(value & 0b0111_1111n);
+			// shift to next section
+			value >>= 7n;
+			// ensure at least 1 sign bit is encoded (0 for positive and 1 for negative)
+			let sign_bit = byte & 0b0100_0000;
+			if ((value == 0n && sign_bit == 0) || (value == -1n && sign_bit != 0))
+				cond = false;
+			// add continuation bit (0 = end byte)
+			else byte |= 0b1000_0000;
+			// add continuation bit (0 = end byte)
+			encode_u8(buf, byte);
+		}
+	}
+}
+
+export function decode_vuint (buf: Buffer, cur: Cursor) {
+	let res = 0n, shift = 0n, cond = true;
+	
+	// while there is input
+	while (cond) {
+		let byte = decode_u8(buf, cur);
+		// add the least significant 7 bits to the next section of the result
+		res |= BigInt(byte & 0b0111_1111) << shift;
+		// next section
+		shift += 7n;
+		// if the continuation bit is set, continue
+		cond = (byte & 0b1000_0000) != 0;
+	}
+
+	return res > 2 ** 50 ? res : Number(res);
+}
+export function decode_vint(buf: Buffer, cur: Cursor) {
+	let res = 0n, shift = 0n, cond = true, byte = 0;
+	
+	// while there is input
+	while (cond) {
+		byte =  decode_u8(buf, cur);
+		// add the least significant 7 bits to the next section of the result
+		res |= BigInt(byte & 0b0111_1111) << shift;
+		// next section
+		shift += 7n;
+		// if the continuation bit is set, continue
+		cond = (byte & 0b1000_0000) != 0;
+	}
+
+	// if the value is neg, sign extend it
+	if ((shift < 64n) && ((byte & 0b0100_0000) !== 0)) {
+		res |= ~0n << shift;
+	}
+
+	return (res > 0 ? res : -res) > 2 ** 50 ? res : Number(res);
+}
+
+export function encode_vuint_pre_aloc(
+	buf: Buffer, value: number, start_ind: number, pre_aloc: number
+) {
+	let nb_buf = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+	let size = 0, cond = true;
+
+	while (cond) {
+		// extract least significant 7 bits
+		let byte = value & 0b0111_1111;
+		// shift to next section
+		value >>= 7;
+		// add continuation bit (0 = end byte)
+		nb_buf[size] = value == 0 ? byte : byte | 0b1000_0000 ;
+
+		cond = value != 0;
+		size += 1;
+	}
+
+	// case size is larger than pre allocated space, expand to fit
+	if (size > pre_aloc) {
+		let len = buf.pos;
+		reserve(buf, size - pre_aloc);
+		buf.buf.copyWithin(start_ind + size, start_ind + pre_aloc, len);
+	}
+
+	// set continuation bits in all pre allocated area, even if not used, making it padding
+	if (size < pre_aloc) {
+		for (let i = 0; i < pre_aloc - 1; i++) {
+			nb_buf[i] |= 0b1000_0000
+		}
+		size = pre_aloc;
+	}
+
+	for (let ind = 0; ind < size; ind++) buf.buf[ind + start_ind] = nb_buf[ind];
+}

package/src/rich.ts

@@ -0,0 +1,32 @@
+import { decode_i64, decode_u32, decode_u8_arr, encode_i64, encode_u32, encode_u8_arr, type Buffer, type Cursor } from "./buf.ts";
+import type { Dur, UUID } from "./index.ts";
+
+export function encode_uuid (buf: Buffer, value: UUID) {
+	encode_u8_arr(buf, value.value);
+}
+export function decode_uuid (buf: Buffer, cur: Cursor) {
+	return { type: 'uuid', value: decode_u8_arr(buf, 16, cur) } satisfies UUID
+}
+
+export function encode_inst(buf: Buffer, value: Date) {
+	encode_i64(buf, BigInt(Number(value)))
+}
+export function encode_instN(buf: Buffer, value: Date) {
+	encode_i64(buf, BigInt(Number(value)))
+	encode_u32(buf, 0)
+}
+export function decode_inst(buf: Buffer, cur: Cursor) {
+	return new Date(Number(decode_i64(buf, cur)))
+}
+export function decode_instN(buf: Buffer, cur: Cursor) {
+	let res = decode_i64(buf, cur);
+	decode_u32(buf, cur);
+	return new Date(Number(res))
+}
+
+export function encode_dur(buf: Buffer, value: Dur) {
+	encode_i64(buf, value.value)
+}
+export function decode_dur(buf: Buffer, cur: Cursor) {
+	return { type: 'dur', value: decode_i64(buf, cur) } satisfies Dur
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"compilerOptions": {
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"target": "esnext",
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"moduleDetection": "force",
+		"moduleResolution": "bundler",
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,	
+		"strict": true,
+		"allowImportingTsExtensions": true,
+		"noImplicitOverride": true,	
+		"module": "preserve",
+		"noEmit": true,
+		"lib": ["esnext", "dom"],
+	},
+	"include": ["src/**/*"],
+}