utilium 1.10.1 → 2.0.0-pre.2

package/src/struct.ts

@@ -1,4 +1,4 @@
-import { toUint8Array } from './buffer.js';
+import { BufferViewArray } from './buffer.js';
 import { _debugLog } from './debugging.js';
 import * as primitive from './internal/primitives.js';
 import type {
@@ -6,27 +6,15 @@ import type {
 	Instance,
 	InstanceLike,
 	Member,
-	MemberContext,
-	MemberInit,
 	Metadata,
 	Options,
 	Size,
 	StaticLike,
 	TypeLike,
 } from './internal/struct.js';
-import {
-	_polyfill_metadata,
-	checkInstance,
-	checkStruct,
-	initMetadata,
-	isCustom,
-	isInstance,
-	isStatic,
-	isStruct,
-} from './internal/struct.js';
+import { checkStruct, initMetadata, isInstance, isStatic, isStruct } from './internal/struct.js';
 import { _throw } from './misc.js';
-import { capitalize } from './string.js';
-import type { ClassLike } from './types.js';
+import { getAllPrototypes } from './objects.js';
 export * as Struct from './internal/struct.js';
 
 /**
@@ -49,43 +37,33 @@ export function sizeof<T extends TypeLike>(type: T | T[]): Size<T> {
 	if (typeof type == 'string') {
 		primitive.checkValid(type);
 
-		return (+primitive.normalize(type).match(primitive.regex)![2] / 8) as Size<T>;
+		return primitive.types[primitive.normalize(type)].size as Size<T>;
 	}
 
-	if (isCustom(type)) return type[Symbol.size] as Size<T>;
+	if (primitive.isType(type)) return type.size as Size<T>;
 
 	checkStruct(type);
 
 	const constructor = isStatic(type) ? type : type.constructor;
-	_polyfill_metadata(constructor);
-	const { struct } = constructor[Symbol.metadata];
-
-	let size = struct.staticSize;
-
-	if (isStatic(type)) return size as Size<T>;
+	const { struct, structInit } = constructor[Symbol.metadata];
 
-	for (const member of struct.members.values()) {
-		const value = (type as any)[member.name];
-
-		if (isInstance(value) && value.constructor[Symbol.metadata].struct.isDynamic) {
-			if (struct.isUnion) size = Math.max(size, sizeof(value));
-			else size += sizeof(value);
-			continue;
-		}
+	if (isStatic(type) || !struct.isDynamic) return struct.staticSize as Size<T>;
 
-		if (typeof member.length != 'string') continue;
+	const last = structInit.members.at(-1)!;
+	const length = (type as any)[last.length as keyof typeof type];
+	let dynamicSize = 0;
 
-		let subSize = 0;
+	if (primitive.isType(last.type)) {
+		dynamicSize = last.type.size * length;
+	} else {
+		const value = type[last.name];
 
-		for (let i = 0; i < (type as any)[member.length]; i++) {
-			subSize += sizeof(isStruct(value[i]) ? value[i] : member.type);
+		for (let i = 0; i < length; i++) {
+			dynamicSize += sizeof(isStruct(value[i]) ? value[i] : last.type);
 		}
-
-		if (struct.isUnion) size = Math.max(size, subSize);
-		else size += subSize;
 	}
 
-	return size as Size<T>;
+	return (struct.isUnion ? Math.max(struct.staticSize, dynamicSize) : struct.staticSize + dynamicSize) as Size<T>;
 }
 
 /**
@@ -96,31 +74,14 @@ export function offsetof(type: StaticLike | InstanceLike, memberName: string): n
 
 	const constructor = isStatic(type) ? type : type.constructor;
 
-	_polyfill_metadata(constructor);
-	const { struct } = constructor[Symbol.metadata];
-
-	if (isStatic(type) || !struct.isDynamic) {
-		return (
-			struct.members.get(memberName)?.staticOffset
-			?? _throw(new Error('Struct does not have member: ' + memberName))
-		);
-	}
-
-	let offset = 0;
-
-	for (const member of struct.members.values()) {
-		if (member.name == memberName) return offset;
+	const member = constructor[Symbol.metadata].struct.members.get(memberName);
 
-		const value = (type as any)[member.name];
-		offset += sizeof(isStruct(value) ? value : member.type);
-	}
+	if (!member) throw new Error('Struct does not have member: ' + memberName);
 
-	throw new Error('Struct does not have member: ' + memberName);
+	return member.offset;
 }
 
-/**
- * Aligns a number
- */
+/** Aligns a number */
 export function align(value: number, alignment: number): number {
 	return Math.ceil(value / alignment) * alignment;
 }
@@ -129,68 +90,51 @@ export function align(value: number, alignment: number): number {
  * Decorates a class as a struct
  */
 export function struct(options: Partial<Options> = {}) {
-	return function _decorateStruct<const T extends StaticLike>(
+	return function _decorateStruct<T extends StaticLike>(
 		target: T,
-		context: ClassDecoratorContext & DecoratorContext
-	): T {
-		const members = new Map<string, Member>();
-
-		let staticSize = 0,
-			isDynamic = false;
-
-		for (const { name, type, length } of initMetadata(context)) {
-			if (!primitive.isValid(type) && !isStatic(type)) throw new TypeError('Not a valid type: ' + type);
-
-			if (typeof length == 'string') {
-				const countedBy = members.get(length);
+		context: ClassDecoratorContext<T> & DecoratorContext
+	): void {
+		const init = initMetadata(context);
 
-				if (!countedBy) throw new Error(`"${length}" is undefined or declared after "${name}"`);
-
-				if (!primitive.isType(countedBy.type))
-					throw new Error(`"${length}" is not a number and cannot be used to count "${name}"`);
-			}
-
-			let decl = `${typeof type == 'string' ? type : type.name} ${name}`;
-
-			if (length !== undefined) decl += `[${length}]`;
-
-			members.set(name, {
-				name,
-				staticOffset: options.isUnion ? 0 : staticSize,
-				type: primitive.isValid(type) ? primitive.normalize(type) : type,
-				length,
-				decl,
-			});
+		const members = new Map<string, Member>();
 
-			const memberSize =
-				typeof length == 'string' || (isStatic(type) && type[Symbol.metadata].struct.isDynamic)
-					? 0
-					: sizeof(type) * (length || 1);
+		for (const member of init.members) {
+			if (options.isUnion) member.offset = 0;
 
-			isDynamic ||= isStatic(type) ? type[Symbol.metadata].struct.isDynamic : typeof length == 'string';
-			staticSize = options.isUnion ? Math.max(staticSize, memberSize) : staticSize + memberSize;
-			staticSize = align(staticSize, options.align || 1);
+			_debugLog('define', target.name + '.' + member.name);
 
-			_debugLog('define', target.name + '.' + name);
+			members.set(member.name, member);
 		}
 
 		context.metadata.struct = {
 			options,
 			members,
-			staticSize,
-			isDynamic,
+			staticSize: init.size,
+			isDynamic: init.isDynamic,
 			isUnion: options.isUnion ?? false,
 		} satisfies Metadata;
-
-		return target;
 	};
 }
 
+export interface MemberOptions {
+	bigEndian?: boolean;
+	length?: number;
+	align?: number;
+	typeName?: string;
+	countedBy?: string;
+}
+
 /**
  * Decorates a class member to be serialized
  */
-export function member(type: primitive.Valid | ClassLike, length?: number | string) {
-	return function <V>(value: V, context: MemberContext): V {
+export function member<V>(type: primitive.Type | StaticLike, opt: MemberOptions = {}) {
+	return function __decorateMember(value: Target<V>, context: Context<V>): Result<V> {
+		if (context.kind != 'accessor') throw new Error('Member must be an accessor');
+
+		const init = initMetadata(context);
+
+		if (init.isDynamic) throw new Error('Dynamic members must be declared at the end of the struct');
+
 		let name = context.name;
 		if (typeof name == 'symbol') {
 			console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
@@ -199,199 +143,145 @@ export function member(type: primitive.Valid | ClassLike, length?: number | stri
 
 		if (!name) throw new ReferenceError('Invalid name for struct member');
 
-		initMetadata(context).push({ name, type, length } satisfies MemberInit);
-		return value;
-	};
-}
+		if (!primitive.isType(type) && !isStatic(type)) throw new TypeError('Not a valid type: ' + type.name);
 
-/** Gets the length of a member */
-function _memberLength<T extends Metadata>(instance: Instance<T>, member: Member): number {
-	if (member.length === undefined) return -1;
-	if (typeof member.length == 'string') return (instance as any)[member.length];
-	return Number.isSafeInteger(member.length) && member.length >= 0
-		? member.length
-		: _throw(new Error('Array lengths must be natural numbers'));
-}
+		if (typeof opt.length == 'string') {
+			const countedBy = init.members.find(m => m.name == opt.countedBy);
 
-/**
- * Serializes a struct into a Uint8Array
- */
-export function serialize(instance: unknown): Uint8Array {
-	if (isCustom(instance) && typeof instance[Symbol.serialize] == 'function') return instance[Symbol.serialize]!();
+			if (!countedBy) throw new Error(`"${opt.countedBy}" is not declared and cannot be used to count "${name}"`);
 
-	checkInstance(instance);
-	_polyfill_metadata(instance.constructor);
-	const { options, members } = instance.constructor[Symbol.metadata].struct;
+			if (!primitive.isType(countedBy.type))
+				throw new Error(`"${opt.countedBy}" is not a number and cannot be used to count "${name}"`);
 
-	const size = sizeof(instance);
-	const buffer = new Uint8Array(size);
-	const view = new DataView(buffer.buffer);
+			init.isDynamic = true;
+		}
 
-	_debugLog('serialize', instance.constructor.name);
+		const size = align(
+			sizeof(type) * (typeof opt.length == 'string' ? 0 : (opt.length ?? 1)),
+			opt.align ?? sizeof(type)
+		);
 
-	let offset = 0,
-		nextOffset = 0;
+		const member = {
+			name,
+			offset: init.size,
+			type,
+			length: opt.length,
+			countedBy: opt.countedBy,
+			size,
+			decl: `${opt.typeName ?? type.name} ${name}${opt.length !== undefined ? `[${JSON.stringify(opt.length)}]` : ''}`,
+			littleEndian: !opt.bigEndian,
+		} satisfies Member;
+
+		init.members.push(member);
+
+		// Apply after setting `offset`
+		init.size += size;
+
+		return {
+			get() {
+				return _get(this, member);
+			},
+			set(value) {
+				_set(this, member, value);
+			},
+		};
+	};
+}
 
-	// for unions we should write members in ascending last modified order, but we don't have that info.
-	for (const member of members.values()) {
-		const length = _memberLength(instance, member);
+/** Gets the length of a member */
+function _memberLength<T extends Metadata>(instance: Instance<T>, length?: number, countedBy?: string): number {
+	if (length === undefined) return -1;
+	if (typeof countedBy == 'string') length = Math.min(length, instance[countedBy]);
+	return Number.isSafeInteger(length) && length >= 0
+		? length
+		: _throw(new Error('Array lengths must be natural numbers'));
+}
 
-		_debugLog('\t', member.decl);
+function _set(instance: Instance, member: Member, value: any, index?: number) {
+	const { name, type, length: maxLength, countedBy } = member;
+	const length = _memberLength(instance, maxLength, countedBy);
 
-		for (let i = 0; i < Math.abs(length); i++) {
-			let value = length != -1 ? instance[member.name][i] : instance[member.name];
-			if (typeof value == 'string') {
-				value = value.charCodeAt(0);
-			}
+	if (!primitive.isType(type)) {
+		if (!isInstance(value)) return _debugLog(`Tried to set "${name}" to a non-instance value`);
 
-			offset = nextOffset;
-			nextOffset += isInstance(value) ? sizeof(value) : sizeof(member.type);
+		if (length > 0 && typeof index != 'number') {
+			for (let i = 0; i < length; i++) _set(instance, member, value[i], i);
+			return;
+		}
 
-			if (!primitive.isType(member.type)) {
-				buffer.set(value ? serialize(value) : new Uint8Array(sizeof(member.type)), offset);
-				continue;
-			}
+		if (!Array.from(getAllPrototypes(value.constructor)).some(c => c === type))
+			throw new Error(`${value.constructor.name} is not a subtype of ${type.name}`);
 
-			const fn = `set${capitalize(member.type)}` as const;
+		const offset = instance.byteOffset + member.offset + (index ?? 0) * sizeof(type);
 
-			if (fn == 'setInt64') {
-				view.setBigInt64(offset, BigInt(value), !options.bigEndian);
-				continue;
-			}
+		// It's already the same value
+		if (value.buffer === instance.buffer && value.byteOffset === offset) return;
 
-			if (fn == 'setUint64') {
-				view.setBigUint64(offset, BigInt(value), !options.bigEndian);
-				continue;
-			}
+		const current = new Uint8Array(instance.buffer, offset, sizeof(value));
 
-			if (fn == 'setInt128') {
-				view.setBigUint64(offset + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-				view.setBigInt64(offset + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
-				continue;
-			}
+		current.set(new Uint8Array(value.buffer, value.byteOffset, sizeof(value)));
 
-			if (fn == 'setUint128') {
-				view.setBigUint64(offset + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-				view.setBigUint64(offset + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
-				continue;
-			}
+		return;
+	}
 
-			if (fn == 'setFloat128') {
-				view.setFloat64(offset + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
-				view.setBigUint64(offset + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
-				continue;
-			}
+	const view = new DataView(instance.buffer, instance.byteOffset, instance.byteLength);
 
-			view[fn](offset, Number(value), !options.bigEndian);
+	if (length > 0 && typeof index != 'number') {
+		for (let i = 0; i < length; i++) {
+			const offset = member.offset + i * type.size;
+			type.set(view, offset, member.littleEndian, value[i]);
 		}
+		return;
 	}
 
-	return buffer;
-}
-
-/**
- * Deserializes a struct from a Uint8Array
- */
-export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayBufferView) {
-	const buffer = toUint8Array(_buffer);
-
-	if (isCustom(instance) && typeof instance[Symbol.deserialize] == 'function')
-		return instance[Symbol.deserialize]!(buffer);
-
-	checkInstance(instance);
-	_polyfill_metadata(instance.constructor);
-	const { options, members } = instance.constructor[Symbol.metadata].struct;
-
-	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-
-	_debugLog('deserialize', instance.constructor.name);
-
-	let offset = 0,
-		nextOffset = 0;
+	if (typeof value == 'string') value = value.charCodeAt(0);
 
-	for (const member of members.values()) {
-		const length = _memberLength(instance, member);
-
-		_debugLog('\t', member.decl);
-
-		for (let i = 0; i < Math.abs(length); i++) {
-			let object = length != -1 ? instance[member.name] : instance;
-			const key = length != -1 ? i : member.name;
-
-			const isNullish = object[key] === null || object[key] === undefined;
-
-			const needsAllocation = isNullish && isStatic(member.type) && member.type[Symbol.metadata].struct.isDynamic;
-
-			offset = nextOffset;
-			if (!isInstance(object[key]) && !needsAllocation) nextOffset += sizeof(member.type);
-
-			if (typeof instance[member.name] == 'string') {
-				instance[member.name] =
-					instance[member.name].slice(0, i)
-					+ String.fromCharCode(view.getUint8(offset))
-					+ instance[member.name].slice(i + 1);
-				continue;
-			}
-
-			if (!primitive.isType(member.type)) {
-				if (needsAllocation && isStatic(member.type)) object[key] ??= new member.type();
-				else if (isNullish) continue;
-
-				deserialize(object[key], new Uint8Array(buffer.subarray(offset)));
-				nextOffset += sizeof(object[key]);
-				continue;
-			}
-
-			if (length && length != -1) object ||= [];
-
-			const fn = `get${capitalize(member.type)}` as const;
-			if (fn == 'getInt64') {
-				object[key] = view.getBigInt64(offset, !options.bigEndian);
-				continue;
-			}
+	type.set(view, member.offset + (index ?? 0) * type.size, member.littleEndian, value);
+}
 
-			if (fn == 'getUint64') {
-				object[key] = view.getBigUint64(offset, !options.bigEndian);
-				continue;
-			}
+function _get(instance: Instance, member: Member, index?: number) {
+	const { type, length: maxLength, countedBy } = member;
+	const length = _memberLength(instance, maxLength, countedBy);
 
-			if (fn == 'getInt128') {
-				object[key] =
-					(view.getBigInt64(offset + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-					| view.getBigUint64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-				continue;
-			}
+	if (length > 0 && typeof index != 'number') {
+		return new (primitive.isType(type) ? type.array : BufferViewArray(type, sizeof(type)))(
+			instance.buffer,
+			instance.byteOffset + member.offset,
+			length * sizeof(type)
+		);
+	}
 
-			if (fn == 'getUint128') {
-				object[key] =
-					(view.getBigUint64(offset + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-					| view.getBigUint64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-				continue;
-			}
+	const offset = member.offset + (index ?? 0) * sizeof(type);
 
-			if (fn == 'getFloat128') {
-				object[key] = view.getFloat64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-				continue;
-			}
+	if (isStatic(type)) return new type(instance.buffer, offset, sizeof(type));
 
-			object[key] = view[fn](offset, !options.bigEndian);
-		}
-	}
+	const view = new DataView(instance.buffer, instance.byteOffset, instance.byteLength);
+	return type.get(view, offset, member.littleEndian);
 }
 
-function _member<T extends primitive.Valid>(type: T) {
-	function _structMemberDecorator<const V>(length: number | string): (value: V, context: MemberContext) => V;
-	function _structMemberDecorator<const V>(value: V, context: MemberContext): V;
-	function _structMemberDecorator<const V>(
-		valueOrLength: V | number | string,
-		context?: MemberContext
-	): V | ((value: V, context: MemberContext) => V) {
-		if (typeof valueOrLength == 'number' || typeof valueOrLength == 'string') {
-			return member(type, valueOrLength as number);
-		}
-
-		return member(type)(valueOrLength, context!);
+// Decorator utility types
+type Target<V> = ClassAccessorDecoratorTarget<any, V>;
+type Result<V> = ClassAccessorDecoratorResult<any, V>;
+type Context<V> = ClassAccessorDecoratorContext<any, V> & DecoratorContext;
+type Decorator<V> = (value: Target<V>, context: Context<V>) => Result<V>;
+
+function _member<T extends primitive.Valid>(typeName: T) {
+	const type = primitive.types[primitive.normalize(typeName)];
+
+	function _structMemberDecorator<V>(length: number, options?: Omit<MemberOptions, 'length'>): Decorator<V>;
+	function _structMemberDecorator<V>(value: Target<V>, context: Context<V>): Result<V>;
+	function _structMemberDecorator<V>(
+		valueOrLength: Target<V> | number,
+		context?: Context<V> | Omit<MemberOptions, 'length'>
+	): Decorator<V> | Result<V> {
+		return typeof valueOrLength == 'number'
+			? member<V>(type, { typeName, length: valueOrLength, ...context })
+			: member<V>(type, { typeName })(
+					valueOrLength,
+					context && 'name' in context ? context : _throw('Invalid decorator context object')
+				);
 	}
+
 	return _structMemberDecorator;
 }