utilium 2.0.0-pre.1 → 2.0.0

package/dist/buffer.d.ts

@@ -238,7 +238,7 @@ export declare class BufferView<T extends ArrayBufferLike = ArrayBufferLike> imp
     readonly byteLength: number;
     constructor(buffer?: T | ArrayBufferView<T> | ArrayLike<number>, byteOffset?: number, byteLength?: number);
 }
-/** Creates an array of a buffer view type */
+/** Creates a fixed-size array of a buffer view type */
 export declare function BufferViewArray<T extends ArrayBufferViewConstructor>(element: T, size: number): {
     new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer?: TArrayBuffer | ArrayBufferView<TArrayBuffer> | ArrayLike<number>, byteOffset?: number, byteLength?: number): {
         [n: number]: any;

package/dist/buffer.js

@@ -40,7 +40,7 @@ export function toUint8Array(buffer) {
 }
 export function initView(view, buffer, byteOffset, byteLength) {
     if (typeof buffer == 'number') {
-        const per = view.BYTES_PER_ELEMENT ?? _throw('BYTES_PER_ELEMENT is not set');
+        const per = view.BYTES_PER_ELEMENT ?? _throw(new Error('BYTES_PER_ELEMENT is not set'));
         view.buffer = new ArrayBuffer(buffer * per);
         view.byteOffset = 0;
         view.byteLength = buffer * per;
@@ -77,19 +77,18 @@ export class BufferView {
     }
 }
 BufferView;
-/** Creates an array of a buffer view type */
+/** Creates a fixed-size array of a buffer view type */
 export function BufferViewArray(element, size) {
     return class BufferViewArray extends Array {
         BYTES_PER_ELEMENT = size;
         constructor(buffer, byteOffset, byteLength) {
-            const t_size = size;
-            const length = (byteLength ?? t_size) / t_size;
+            const length = (byteLength ?? size) / size;
             if (!Number.isSafeInteger(length))
                 throw new Error('Invalid array length: ' + length);
             super(length);
             initView(this, buffer, byteOffset, byteLength);
             for (let i = 0; i < length; i++) {
-                this[i] = new element(this.buffer, this.byteOffset + i * t_size, t_size);
+                this[i] = new element(this.buffer, this.byteOffset + i * size, size);
             }
         }
     };

package/dist/index.d.ts

@@ -4,6 +4,5 @@ export * from './numbers.js';
 export * from './objects.js';
 export * from './random.js';
 export * from './string.js';
-export * from './struct.js';
 export * from './types.js';
 export * as version from './version.js';

package/dist/index.js

@@ -1,4 +1,3 @@
-// This file should not be added to
 // For better tree shaking, import from whichever file is actually needed
 export * from './list.js';
 export * from './misc.js';
@@ -6,6 +5,5 @@ export * from './numbers.js';
 export * from './objects.js';
 export * from './random.js';
 export * from './string.js';
-export * from './struct.js';
 export * from './types.js';
 export * as version from './version.js';

package/eslint.shared.js

@@ -0,0 +1,66 @@
+/* Shared eslint rules */
+import eslint from '@eslint/js';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+export default function (tsconfigRootDir) {
+	return tseslint.config(
+		{
+			name: 'Utilium',
+			extends: [eslint.configs.recommended, ...tseslint.configs.recommendedTypeChecked],
+			files: ['src/**/*.ts', 'tests/**/*.ts'],
+			languageOptions: {
+				globals: { ...globals.browser, ...globals.node },
+				ecmaVersion: 'latest',
+				sourceType: 'module',
+				parserOptions: {
+					projectService: true,
+					tsconfigRootDir,
+				},
+			},
+			rules: {
+				'no-useless-escape': 'warn',
+				'no-unreachable': 'warn',
+				'no-fallthrough': 'warn',
+				'no-empty': 'warn',
+				'no-case-declarations': 'warn',
+				'prefer-const': 'warn',
+				'prefer-rest-params': 'warn',
+				'prefer-spread': 'warn',
+				'no-unused-vars': 'off',
+				'@typescript-eslint/no-unused-vars': 'warn',
+				'@typescript-eslint/no-inferrable-types': 'off',
+				'@typescript-eslint/no-this-alias': 'off',
+				'@typescript-eslint/no-unsafe-function-type': 'warn',
+				'@typescript-eslint/no-wrapper-object-types': 'warn',
+				'@typescript-eslint/triple-slash-reference': 'warn',
+				'@typescript-eslint/no-non-null-assertion': 'off',
+				'@typescript-eslint/no-namespace': 'warn',
+				'@typescript-eslint/prefer-as-const': 'warn',
+				'@typescript-eslint/no-explicit-any': 'warn',
+				'@typescript-eslint/consistent-type-assertions': 'warn',
+				'@typescript-eslint/consistent-type-imports': 'warn',
+				'@typescript-eslint/no-unnecessary-type-assertion': 'warn',
+				'@typescript-eslint/require-await': 'warn',
+				'@typescript-eslint/no-unsafe-return': 'off',
+				'@typescript-eslint/no-unsafe-assignment': 'off',
+				'@typescript-eslint/no-unsafe-member-access': 'off',
+				'@typescript-eslint/no-unsafe-argument': 'off',
+				'@typescript-eslint/no-redundant-type-constituents': 'warn',
+				'@typescript-eslint/no-unsafe-call': 'warn',
+				'@typescript-eslint/restrict-plus-operands': 'off',
+			},
+		},
+		{
+			name: 'Tests overrides',
+			files: ['tests/**/*.ts'],
+			rules: {
+				'@typescript-eslint/no-unsafe-member-access': 'off',
+				'@typescript-eslint/no-unsafe-argument': 'off',
+				'@typescript-eslint/no-unsafe-assignment': 'off',
+				'@typescript-eslint/no-floating-promises': 'off',
+				'@typescript-eslint/no-explicit-any': 'off',
+			},
+		}
+	);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "2.0.0-pre.1",
+	"version": "2.0.0",
 	"description": "Typescript utilities",
 	"funding": {
 		"type": "individual",
@@ -12,23 +12,17 @@
 	"exports": {
 		".": "./dist/index.js",
 		"./*": "./dist/*",
-		"./eslint": "./eslint.shared.js",
-		"./source": "./src/*"
+		"./eslint": "./eslint.shared.js"
 	},
 	"files": [
-		"src",
 		"dist",
-		"tsconfig.json",
-		"scripts"
+		"eslint.shared.js"
 	],
 	"scripts": {
 		"format:check": "prettier --check .",
 		"format": "prettier --write .",
 		"lint": "tsc --noEmit && eslint src",
-		"test": "tsx --test",
-		"build": "tsc -p tsconfig.json",
-		"build:docs": "typedoc",
-		"prepublishOnly": "npm run build"
+		"prepublishOnly": "npx tsc"
 	},
 	"repository": {
 		"type": "git",

package/readme.md

@@ -2,7 +2,6 @@
 
 A bunch of utilities for Typescript. This includes:
 
-- Structs (using decorators)
 - Compile-time math types
 - Debugging types and functions
 - Utilities for using `fetch` with [HTTP range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests)

package/dist/internal/primitives.d.ts

@@ -1,99 +0,0 @@
-import type { ArrayBufferViewConstructor } from '../buffer.js';
-import type { UnionToTuple } from '../types.js';
-/** A definition for a primitive type */
-export interface Type<T = any> {
-    readonly name: string;
-    readonly size: number;
-    readonly array: ArrayBufferViewConstructor;
-    get(this: void, view: DataView, offset: number, littleEndian: boolean): T;
-    set(this: void, view: DataView, offset: number, littleEndian: boolean, value: T): void;
-}
-export declare function isType<T = any>(type: unknown): type is Type<T>;
-export declare const types: {
-    readonly int8: {
-        readonly name: "int8";
-        readonly size: 1;
-        readonly array: Int8ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, _le: boolean, value: any) => void;
-    };
-    readonly uint8: {
-        readonly name: "uint8";
-        readonly size: 1;
-        readonly array: Uint8ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, _le: boolean, value: any) => void;
-    };
-    readonly int16: {
-        readonly name: "int16";
-        readonly size: 2;
-        readonly array: Int16ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly uint16: {
-        readonly name: "uint16";
-        readonly size: 2;
-        readonly array: Uint16ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly int32: {
-        readonly name: "int32";
-        readonly size: 4;
-        readonly array: Int32ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly uint32: {
-        readonly name: "uint32";
-        readonly size: 4;
-        readonly array: Uint32ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly int64: {
-        readonly name: "int64";
-        readonly size: 8;
-        readonly array: BigInt64ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => bigint;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly uint64: {
-        readonly name: "uint64";
-        readonly size: 8;
-        readonly array: BigUint64ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => bigint;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly float32: {
-        readonly name: "float32";
-        readonly size: 4;
-        readonly array: Float32ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-    readonly float64: {
-        readonly name: "float64";
-        readonly size: 8;
-        readonly array: Float64ArrayConstructor;
-        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
-        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
-    };
-};
-export type TypeName = keyof typeof types;
-export declare const typeNames: UnionToTuple<TypeName>;
-export declare function isTypeName(type: {
-    toString(): string;
-}): type is TypeName;
-export type Valid = TypeName | Capitalize<TypeName> | 'char';
-export declare const validNames: ("int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" | "Int8" | "Uint8" | "Int16" | "Uint16" | "Int32" | "Uint32" | "Int64" | "Uint64" | "Float32" | "Float64" | "char")[];
-export declare function isValid(type: {
-    toString(): string;
-}): type is Valid;
-export declare function checkValid(type: {
-    toString(): string;
-}): asserts type is Valid;
-export type Normalize<T extends Valid> = (T extends 'char' ? 'uint8' : Uncapitalize<T>) & TypeName;
-export declare function normalize<T extends Valid>(type: T): Normalize<T>;
-export type Size<T extends Valid | Type> = (T extends Valid ? (typeof types)[Normalize<T>] : T)['size'];

package/dist/internal/primitives.js

@@ -1,98 +0,0 @@
-import { capitalize } from '../string.js';
-export function isType(type) {
-    return (typeof type == 'object'
-        && type != null
-        && 'size' in type
-        && 'get' in type
-        && 'set' in type
-        && typeof type.size == 'number'
-        && typeof type.get == 'function'
-        && typeof type.set == 'function');
-}
-export const types = {
-    int8: {
-        name: 'int8',
-        size: 1,
-        array: Int8Array,
-        get: (view, offset) => view.getInt8(offset),
-        set: (view, offset, _le, value) => view.setInt8(offset, value),
-    },
-    uint8: {
-        name: 'uint8',
-        size: 1,
-        array: Uint8Array,
-        get: (view, offset) => view.getUint8(offset),
-        set: (view, offset, _le, value) => view.setUint8(offset, value),
-    },
-    int16: {
-        name: 'int16',
-        size: 2,
-        array: Int16Array,
-        get: (view, offset, le) => view.getInt16(offset, le),
-        set: (view, offset, le, value) => view.setInt16(offset, value, le),
-    },
-    uint16: {
-        name: 'uint16',
-        size: 2,
-        array: Uint16Array,
-        get: (view, offset, le) => view.getUint16(offset, le),
-        set: (view, offset, le, value) => view.setUint16(offset, value, le),
-    },
-    int32: {
-        name: 'int32',
-        size: 4,
-        array: Int32Array,
-        get: (view, offset, le) => view.getInt32(offset, le),
-        set: (view, offset, le, value) => view.setInt32(offset, value, le),
-    },
-    uint32: {
-        name: 'uint32',
-        size: 4,
-        array: Uint32Array,
-        get: (view, offset, le) => view.getUint32(offset, le),
-        set: (view, offset, le, value) => view.setUint32(offset, value, le),
-    },
-    int64: {
-        name: 'int64',
-        size: 8,
-        array: BigInt64Array,
-        get: (view, offset, le) => view.getBigInt64(offset, le),
-        set: (view, offset, le, value) => view.setBigInt64(offset, value, le),
-    },
-    uint64: {
-        name: 'uint64',
-        size: 8,
-        array: BigUint64Array,
-        get: (view, offset, le) => view.getBigUint64(offset, le),
-        set: (view, offset, le, value) => view.setBigUint64(offset, value, le),
-    },
-    float32: {
-        name: 'float32',
-        size: 4,
-        array: Float32Array,
-        get: (view, offset, le) => view.getFloat32(offset, le),
-        set: (view, offset, le, value) => view.setFloat32(offset, value, le),
-    },
-    float64: {
-        name: 'float64',
-        size: 8,
-        array: Float64Array,
-        get: (view, offset, le) => view.getFloat64(offset, le),
-        set: (view, offset, le, value) => view.setFloat64(offset, value, le),
-    },
-};
-export const typeNames = Object.keys(types);
-export function isTypeName(type) {
-    return typeNames.includes(type.toString());
-}
-export const validNames = [...typeNames, ...typeNames.map(t => capitalize(t)), 'char'];
-export function isValid(type) {
-    return validNames.includes(type.toString());
-}
-export function checkValid(type) {
-    if (!isValid(type))
-        throw new TypeError('Not a valid primitive type: ' + type);
-}
-export function normalize(type) {
-    return (type == 'char' ? 'uint8' : type.toLowerCase());
-}

package/dist/internal/struct.d.ts

@@ -1,77 +0,0 @@
-import type { ClassLike } from '../types.js';
-import type * as primitive from './primitives.js';
-export type TypeLike = primitive.Type | Like | primitive.Valid | undefined | null;
-export type Type = Static | primitive.Type;
-/**
- * Options for struct initialization
- */
-export interface Options {
-    packed: boolean;
-    align: number;
-    isUnion: boolean;
-}
-export interface Member {
-    name: string;
-    type: Type;
-    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 {
-    options: Partial<Options>;
-    members: Map<string, Member>;
-    staticSize: number;
-    /** Whether the struct is dynamically sized */
-    isDynamic: boolean;
-    /** Whether the struct is a union */
-    isUnion: boolean;
-}
-export interface Init {
-    members: Member[];
-    size: number;
-    isDynamic: boolean;
-    isUnion: boolean;
-}
-type _DecoratorMetadata<T extends Metadata = Metadata> = DecoratorMetadata & {
-    struct?: T;
-    structInit?: Init;
-};
-export interface DecoratorContext<T extends Metadata = Metadata> {
-    metadata: _DecoratorMetadata<T>;
-}
-/**
- * Initializes the struct metadata for a class
- * This also handles copying metadata from parent classes
- */
-export declare function initMetadata(context: DecoratorContext): Init;
-export interface Static<T extends Metadata = Metadata> {
-    [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;
-}
-export declare function isValidMetadata<T extends Metadata = Metadata>(arg: unknown): arg is DecoratorMetadata & {
-    struct: T;
-};
-export declare function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T>;
-export interface Instance<T extends Metadata = Metadata> extends ArrayBufferView, Record<PropertyKey, any> {
-    constructor: Static<T>;
-}
-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> & Record<keyof any, any>;
-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 TypeLike> = T extends undefined | null ? 0 : T extends primitive.Valid ? primitive.Size<T> : number;
-export {};

package/dist/internal/struct.js

@@ -1,44 +0,0 @@
-/**
- * Polyfill Symbol.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- */
-Symbol.metadata ??= Symbol.for('Symbol.metadata');
-/**
- * Initializes the struct metadata for a class
- * This also handles copying metadata from parent classes
- */
-export function initMetadata(context) {
-    context.metadata ??= {};
-    const existing = 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 function isValidMetadata(arg) {
-    return arg != null && typeof arg == 'object' && 'struct' in arg;
-}
-export function isStatic(arg) {
-    return typeof arg == 'function' && Symbol.metadata in arg && isValidMetadata(arg[Symbol.metadata]);
-}
-export function isInstance(arg) {
-    return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
-}
-export function checkInstance(arg) {
-    if (isInstance(arg))
-        return;
-    throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == '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))
-        return;
-    throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
-        + ' is not a struct');
-}

package/dist/struct.d.ts

@@ -1,41 +0,0 @@
-import * as primitive from './internal/primitives.js';
-import type { DecoratorContext, InstanceLike, Options, Size, StaticLike, TypeLike } from './internal/struct.js';
-export * as Struct from './internal/struct.js';
-/**
- * Gets the size in bytes of a type
- */
-export declare function sizeof<T extends TypeLike>(type: T | T[]): Size<T>;
-/**
- * Returns the offset (in bytes) of a member in a struct.
- */
-export declare function offsetof(type: StaticLike | InstanceLike, memberName: string): number;
-/** Aligns a number */
-export declare function align(value: number, alignment: number): number;
-/**
- * Decorates a class as a struct
- */
-export declare function struct(options?: Partial<Options>): <T extends StaticLike>(target: T, context: ClassDecoratorContext<T> & DecoratorContext) => void;
-export interface MemberOptions {
-    bigEndian?: boolean;
-    length?: number | string;
-    align?: number;
-    typeName?: string;
-}
-/**
- * Decorates a class member to be serialized
- */
-export declare function member<V>(type: primitive.Type | StaticLike, opt?: MemberOptions): (value: Target<V>, context: Context<V>) => Result<V>;
-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>;
-declare function _member<T extends primitive.Valid>(typeName: T): {
-    <V>(length: number | string): Decorator<V>;
-    <V>(value: Target<V>, context: Context<V>): Result<V>;
-};
-/**
- * Shortcut types
- *
- * Instead of writing `@member(type)` you can write `@types.type`, or `@types.type(length)` for arrays
- */
-export declare const types: { [K in primitive.Valid]: ReturnType<typeof _member<K>>; };