utilium 0.7.0 → 0.7.2

package/dist/internal/primitives.d.ts

@@ -18,4 +18,7 @@ export declare function isType(type: {
 export declare function isValid(type: {
     toString(): string;
 }): type is Valid;
+export declare function checkValid(type: {
+    toString(): string;
+}): asserts type is Valid;
 export {};

package/dist/internal/primitives.js

@@ -1,7 +1,7 @@
 import { capitalize } from '../string.js';
 export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'];
 export const valids = [...types, ...types.map(t => capitalize(t)), 'char'];
-export const regex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
+export const regex = /^(u?int|float)(8|16|32|64)$/i;
 export function normalize(type) {
     return (type == 'char' ? 'uint8' : type.toLowerCase());
 }
@@ -11,3 +11,8 @@ export function isType(type) {
 export function isValid(type) {
     return type == 'char' || regex.test(type.toString().toLowerCase());
 }
+export function checkValid(type) {
+    if (!isValid(type)) {
+        throw new TypeError('Not a valid primitive type: ' + type);
+    }
+}

package/dist/internal/struct.d.ts

@@ -57,6 +57,8 @@ export interface InstanceLike<T extends Metadata = Metadata> {
     constructor: StaticLike<T>;
 }
 export declare function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T>;
+export declare function checkInstance<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T>;
 export declare function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T>;
+export declare function checkStruct<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> | Static<T>;
 export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
 export type Size<T extends primitive.Valid | StaticLike | InstanceLike> = T extends primitive.Valid ? primitive.Size<T> : T extends Like<infer M> ? M['size'] : number;

package/dist/internal/struct.js

@@ -19,6 +19,16 @@ export function isStatic(arg) {
 export function isInstance(arg) {
     return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
+export function checkInstance(arg) {
+    if (!isInstance(arg)) {
+        throw new TypeError((typeof arg == 'function' ? arg.name : 'object' && arg ? arg.constructor.name : arg) + ' is not a struct instance');
+    }
+}
 export function isStruct(arg) {
     return isInstance(arg) || isStatic(arg);
 }
+export function checkStruct(arg) {
+    if (!isStruct(arg)) {
+        throw new TypeError((typeof arg == 'function' ? arg.name : 'object' && arg ? arg.constructor.name : arg) + ' is not a struct');
+    }
+}

package/dist/list.js

@@ -12,10 +12,10 @@ export class List extends EventEmitter {
         return new Set(this.data);
     }
     toArray() {
-        return [...this.data];
+        return Array.from(this.data);
     }
     toJSON() {
-        return JSON.stringify([...this.data]);
+        return JSON.stringify(Array.from(this.data));
     }
     toString() {
         return this.join(',');
@@ -24,7 +24,7 @@ export class List extends EventEmitter {
         if (Math.abs(index) > this.data.size) {
             throw new ReferenceError('Can not set an element outside the bounds of the list');
         }
-        const data = [...this.data];
+        const data = Array.from(this.data);
         data.splice(index, 1, value);
         this.data = new Set(data);
         this.emit('update');
@@ -33,17 +33,17 @@ export class List extends EventEmitter {
         if (Math.abs(index) > this.data.size) {
             throw new ReferenceError('Can not delete an element outside the bounds of the list');
         }
-        this.delete([...this.data].at(index));
+        this.delete(Array.from(this.data).at(index));
     }
     // Array methods
     at(index) {
         if (Math.abs(index) > this.data.size) {
             throw new ReferenceError('Can not access an element outside the bounds of the list');
         }
-        return [...this.data].at(index);
+        return Array.from(this.data).at(index);
     }
     pop() {
-        const item = [...this.data].pop();
+        const item = Array.from(this.data).pop();
         if (item !== undefined) {
             this.delete(item);
         }
@@ -56,13 +56,13 @@ export class List extends EventEmitter {
         return this.data.size;
     }
     join(separator) {
-        return [...this.data].join(separator);
+        return Array.from(this.data).join(separator);
     }
     splice(start, deleteCount, ...items) {
         if (Math.abs(start) > this.data.size) {
             throw new ReferenceError('Can not splice elements outside the bounds of the list');
         }
-        const data = [...this.data];
+        const data = Array.from(this.data);
         const deleted = data.splice(start, deleteCount, ...items);
         this.data = new Set(data);
         this.emit('update');

package/dist/struct.js

@@ -1,5 +1,5 @@
 import * as primitive from './internal/primitives.js';
-import { symbol_metadata, init, isInstance, isStatic, isStruct, metadata, } from './internal/struct.js';
+import { checkInstance, checkStruct, init, isStatic, metadata, symbol_metadata, } from './internal/struct.js';
 import { capitalize } from './string.js';
 export * as Struct from './internal/struct.js';
 /**
@@ -8,14 +8,10 @@ export * as Struct from './internal/struct.js';
 export function sizeof(type) {
     // primitive
     if (typeof type == 'string') {
-        if (!primitive.isValid(type)) {
-            throw new TypeError('Invalid primitive type: ' + type);
-        }
+        primitive.checkValid(type);
         return (+primitive.normalize(type).match(primitive.regex)[2] / 8);
     }
-    if (!isStruct(type)) {
-        throw new TypeError('Not a struct');
-    }
+    checkStruct(type);
     const struct = isStatic(type) ? type : type.constructor;
     return struct[symbol_metadata(struct)][metadata].size;
 }
@@ -30,7 +26,7 @@ export function align(value, alignment) {
  */
 export function struct(options = {}) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return function __decorateStruct(target, context) {
+    return function _decorateStruct(target, context) {
         context.metadata ??= {};
         context.metadata[init] ||= [];
         let size = 0;
@@ -75,9 +71,7 @@ export function member(type, length) {
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance) {
-    if (!isInstance(instance)) {
-        throw new TypeError('Can not serialize, not a struct instance');
-    }
+    checkInstance(instance);
     const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
     const buffer = new Uint8Array(sizeof(instance));
     const view = new DataView(buffer.buffer);
@@ -112,12 +106,10 @@ export function serialize(instance) {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance, _buffer) {
-    if (!isInstance(instance)) {
-        throw new TypeError('Can not deserialize, not a struct instance');
-    }
+    checkInstance(instance);
     const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
-    const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
-    const view = new DataView(buffer.buffer);
+    const buffer = _buffer instanceof Uint8Array ? _buffer : new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
+    const view = new DataView(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
     for (const [name, { type, offset, length }] of members) {
         for (let i = 0; i < (length || 1); i++) {
             // @ts-expect-error 7053

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.7.0",
+	"version": "0.7.2",
 	"description": "Typescript utilies",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/internal/primitives.ts

@@ -15,7 +15,7 @@ export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'in
 
 export const valids = [...types, ...types.map(t => capitalize(t)), 'char'] satisfies Valid[];
 
-export const regex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
+export const regex = /^(u?int|float)(8|16|32|64)$/i;
 
 export type Normalize<T extends Valid> = T extends 'char' ? 'uint8' : Uncapitalize<T>;
 
@@ -30,3 +30,9 @@ export function isType(type: { toString(): string }): type is Type {
 export function isValid(type: { toString(): string }): type is Valid {
 	return type == 'char' || regex.test(type.toString().toLowerCase());
 }
+
+export function checkValid(type: { toString(): string }): asserts type is Valid {
+	if (!isValid(type)) {
+		throw new TypeError('Not a valid primitive type: ' + type);
+	}
+}

package/src/internal/struct.ts

@@ -90,10 +90,22 @@ export function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is
 	return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
 
+export function checkInstance<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> {
+	if (!isInstance(arg)) {
+		throw new TypeError((typeof arg == 'function' ? arg.name : 'object' && arg ? arg.constructor.name : arg) + ' is not a struct instance');
+	}
+}
+
 export function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T> {
 	return isInstance(arg) || isStatic(arg);
 }
 
+export function checkStruct<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> | Static<T> {
+	if (!isStruct(arg)) {
+		throw new TypeError((typeof arg == 'function' ? arg.name : 'object' && arg ? arg.constructor.name : arg) + ' is not a struct');
+	}
+}
+
 export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
 
 export type Size<T extends primitive.Valid | StaticLike | InstanceLike> = T extends primitive.Valid ? primitive.Size<T> : T extends Like<infer M> ? M['size'] : number;

package/src/list.ts

@@ -17,11 +17,11 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 	}
 
 	public toArray(): T[] {
-		return [...this.data];
+		return Array.from(this.data);
 	}
 
 	public toJSON() {
-		return JSON.stringify([...this.data]);
+		return JSON.stringify(Array.from(this.data));
 	}
 
 	public toString() {
@@ -33,7 +33,7 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 			throw new ReferenceError('Can not set an element outside the bounds of the list');
 		}
 
-		const data = [...this.data];
+		const data = Array.from(this.data);
 		data.splice(index, 1, value);
 		this.data = new Set<T>(data);
 		this.emit('update');
@@ -44,7 +44,7 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 			throw new ReferenceError('Can not delete an element outside the bounds of the list');
 		}
 
-		this.delete([...this.data].at(index)!);
+		this.delete(Array.from(this.data).at(index)!);
 	}
 
 	// Array methods
@@ -54,11 +54,11 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 			throw new ReferenceError('Can not access an element outside the bounds of the list');
 		}
 
-		return [...this.data].at(index)!;
+		return Array.from(this.data).at(index)!;
 	}
 
 	public pop(): T | undefined {
-		const item = [...this.data].pop();
+		const item = Array.from(this.data).pop();
 		if (item !== undefined) {
 			this.delete(item);
 		}
@@ -73,7 +73,7 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 	}
 
 	public join(separator?: string): string {
-		return [...this.data].join(separator);
+		return Array.from(this.data).join(separator);
 	}
 
 	public splice(start: number, deleteCount: number, ...items: T[]): T[] {
@@ -81,7 +81,7 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 			throw new ReferenceError('Can not splice elements outside the bounds of the list');
 		}
 
-		const data = [...this.data];
+		const data = Array.from(this.data);
 		const deleted = data.splice(start, deleteCount, ...items);
 		this.data = new Set<T>(data);
 		this.emit('update');

package/src/struct.ts

@@ -1,18 +1,18 @@
 import * as primitive from './internal/primitives.js';
 import {
+	checkInstance,
+	checkStruct,
 	DecoratorContext,
+	init,
 	InstanceLike,
+	isStatic,
 	MemberInit,
 	Metadata,
+	metadata,
 	Options,
 	Size,
 	StaticLike,
 	symbol_metadata,
-	init,
-	isInstance,
-	isStatic,
-	isStruct,
-	metadata,
 	type MemberContext,
 } from './internal/struct.js';
 import { capitalize } from './string.js';
@@ -25,16 +25,12 @@ export * as Struct from './internal/struct.js';
 export function sizeof<T extends primitive.Valid | StaticLike | InstanceLike>(type: T): Size<T> {
 	// primitive
 	if (typeof type == 'string') {
-		if (!primitive.isValid(type)) {
-			throw new TypeError('Invalid primitive type: ' + type);
-		}
+		primitive.checkValid(type);
 
 		return (+primitive.normalize(type).match(primitive.regex)![2] / 8) as Size<T>;
 	}
 
-	if (!isStruct(type)) {
-		throw new TypeError('Not a struct');
-	}
+	checkStruct(type);
 
 	const struct = isStatic(type) ? type : type.constructor;
 
@@ -53,7 +49,7 @@ export function align(value: number, alignment: number): number {
  */
 export function struct(options: Partial<Options> = {}) {
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	return function __decorateStruct<const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext): T {
+	return function _decorateStruct<const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext): T {
 		context.metadata ??= {};
 		context.metadata[init] ||= [];
 		let size = 0;
@@ -103,9 +99,7 @@ export function member(type: primitive.Valid | ClassLike, length?: number) {
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance: unknown): Uint8Array {
-	if (!isInstance(instance)) {
-		throw new TypeError('Can not serialize, not a struct instance');
-	}
+	checkInstance(instance);
 	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
 
 	const buffer = new Uint8Array(sizeof(instance));
@@ -149,14 +143,12 @@ export function serialize(instance: unknown): Uint8Array {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBufferView) {
-	if (!isInstance(instance)) {
-		throw new TypeError('Can not deserialize, not a struct instance');
-	}
+	checkInstance(instance);
 	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
 
-	const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
+	const buffer = _buffer instanceof Uint8Array ? _buffer : new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
 
-	const view = new DataView(buffer.buffer);
+	const view = new DataView(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
 
 	for (const [name, { type, offset, length }] of members) {
 		for (let i = 0; i < (length || 1); i++) {