utilium 1.10.0 → 2.0.0-pre.1

package/src/internal/struct.ts

@@ -1,57 +1,39 @@
 import type { ClassLike } from '../types.js';
 import type * as primitive from './primitives.js';
 
-declare global {
-	interface SymbolConstructor {
-		readonly size: unique symbol;
-		readonly serialize: unique symbol;
-		readonly deserialize: unique symbol;
-	}
-}
-
 /**
  * Polyfill Symbol.metadata
  * @see https://github.com/microsoft/TypeScript/issues/53461
  */
 (Symbol as { metadata: symbol }).metadata ??= Symbol.for('Symbol.metadata');
 
-Object.assign(Symbol, {
-	size: Symbol('uSize'),
-	serialize: Symbol('uSerialize'),
-	deserialize: Symbol('uDeserialize'),
-});
+export type TypeLike = primitive.Type | Like | primitive.Valid | undefined | null;
 
-export type TypeLike = Custom | Like | primitive.Valid | undefined | null;
-
-export type Type = Custom | Static | primitive.Typename;
-
-/**
- * Member initialization data
- * This is needed since class decorators are called *after* member decorators
- */
-export interface MemberInit {
-	name: string;
-	type: string | ClassLike;
-	length?: number | string;
-}
+export type Type = Static | primitive.Type;
 
 /**
  * Options for struct initialization
  */
 export interface Options {
+	packed: boolean;
 	align: number;
-	bigEndian: boolean;
 	isUnion: boolean;
 }
 
 export interface Member {
 	name: string;
 	type: Type;
-	staticOffset: number;
+	offset: number;
+
+	/** The size of the member, 0 for dynamically sized arrays */
+	size: number;
 	length?: number | string;
 
 	/** A C-style type/name declaration string, used for diagnostics */
 	decl: string;
+
+	/** Whether the member is little endian */
+	littleEndian: boolean;
 }
 
 export interface Metadata {
@@ -66,9 +48,16 @@ export interface Metadata {
 	isUnion: boolean;
 }
 
+export interface Init {
+	members: Member[];
+	size: number;
+	isDynamic: boolean;
+	isUnion: boolean;
+}
+
 type _DecoratorMetadata<T extends Metadata = Metadata> = DecoratorMetadata & {
 	struct?: T;
-	structInit?: MemberInit[];
+	structInit?: Init;
 };
 
 export interface DecoratorContext<T extends Metadata = Metadata> {
@@ -79,25 +68,34 @@ export interface DecoratorContext<T extends Metadata = Metadata> {
  * Initializes the struct metadata for a class
  * This also handles copying metadata from parent classes
  */
-export function initMetadata(context: DecoratorContext): MemberInit[] {
+export function initMetadata(context: DecoratorContext): Init {
 	context.metadata ??= {};
 
-	context.metadata.structInit = [...(context.metadata.structInit ?? [])];
+	const existing: Partial<Init> = context.metadata.structInit ?? {};
+
+	context.metadata.structInit = {
+		members: [...(existing.members ?? [])],
+		size: existing.size ?? 0,
+		isDynamic: existing.isDynamic ?? false,
+		isUnion: existing.isUnion ?? false,
+	};
 
 	return context.metadata.structInit;
 }
 
-export type MemberContext = ClassMemberDecoratorContext & DecoratorContext;
-
 export interface Static<T extends Metadata = Metadata> {
-	[Symbol.metadata]: { struct: T };
-	new (): Instance<T>;
-	prototype: Instance<T>;
+	[Symbol.metadata]: Required<_DecoratorMetadata<T>>;
+	readonly prototype: Instance<T>;
+	new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(
+		buffer: TArrayBuffer,
+		byteOffset?: number,
+		length?: number
+	): Instance<T> & ArrayBufferView<TArrayBuffer>;
+	new (array?: ArrayLike<number> | ArrayBuffer): Instance<T>;
 }
 
 export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
 	[Symbol.metadata]?: _DecoratorMetadata<T> | null;
-	new (): unknown;
 }
 
 export function isValidMetadata<T extends Metadata = Metadata>(
@@ -108,27 +106,11 @@ export function isValidMetadata<T extends Metadata = Metadata>(
 	return arg != null && typeof arg == 'object' && 'struct' in arg;
 }
 
-/**
- * Polyfill context.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- * @internal @hidden
- */
-export function _polyfill_metadata(target: object): void {
-	if (Symbol.metadata in target) return;
-
-	Object.defineProperty(target, Symbol.metadata, {
-		enumerable: true,
-		configurable: true,
-		writable: true,
-		value: Object.create(null),
-	});
-}
-
 export function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T> {
 	return typeof arg == 'function' && Symbol.metadata in arg && isValidMetadata(arg[Symbol.metadata]);
 }
 
-export interface Instance<T extends Metadata = Metadata> {
+export interface Instance<T extends Metadata = Metadata> extends ArrayBufferView, Record<PropertyKey, any> {
 	constructor: Static<T>;
 }
 
@@ -162,25 +144,10 @@ export function checkStruct<T extends Metadata = Metadata>(arg: unknown): assert
 	);
 }
 
-/**
- * A "custom" type, which can be used to implement non-builtin size, serialization, and deserialization
- */
-export interface Custom {
-	readonly [Symbol.size]: number;
-	[Symbol.serialize]?(): Uint8Array;
-	[Symbol.deserialize]?(value: Uint8Array): void;
-}
-
-export function isCustom(arg: unknown): arg is Custom {
-	return typeof arg == 'object' && arg != null && Symbol.size in arg;
-}
-
 export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
 
 export type Size<T extends TypeLike> = T extends undefined | null
 	? 0
-	: T extends { readonly [Symbol.size]: infer S extends number }
-		? S
-		: T extends primitive.Valid
-			? primitive.Size<T>
-			: number;
+	: T extends primitive.Valid
+		? primitive.Size<T>
+		: number;

package/src/objects.ts

@@ -136,3 +136,10 @@ export function bindFunctions<T extends object, This = any>(fns: T, thisValue: T
 		Object.entries(fns).map(([k, v]) => [k, typeof v == 'function' ? v.bind(thisValue) : v])
 	) as Bound<T, This>;
 }
+
+/**
+ * Makes all properties in T mutable
+ */
+export type Mutable<T> = {
+	-readonly [P in keyof T]: T[P];
+};

package/src/string.ts

@@ -36,7 +36,13 @@ const decoder = new TextDecoder();
  * Decodes a UTF-8 string from a buffer
  */
 export function decodeUTF8(input?: Uint8Array): string {
-	return decoder.decode(input);
+	if (!input) return '';
+
+	if (input.buffer instanceof ArrayBuffer && !input.buffer.resizable) return decoder.decode(input);
+
+	const buffer = new Uint8Array(input.byteLength);
+	buffer.set(input);
+	return decoder.decode(buffer);
 }
 
 export function encodeASCII(input: string): Uint8Array {