utilium 2.0.0-pre.2 → 2.0.0

package/src/cache.ts

@@ -1,241 +0,0 @@
-/** A ranged cache */
-import { extendBuffer } from './buffer.js';
-
-export interface Options {
-	/**
-	 * If true, use multiple buffers to cache a file.
-	 * This is useful when working with small parts of large files,
-	 * since we don't need to allocate a large buffer that is mostly unused
-	 * @default true
-	 */
-	sparse?: boolean;
-
-	/**
-	 * The threshold for whether to combine regions or not
-	 * @see Region
-	 * @default 0xfff // 4 KiB
-	 */
-	regionGapThreshold?: number;
-
-	/**
-	 * Whether to only update the cache when changing or deleting resources
-	 * @default false
-	 */
-	cacheOnly?: boolean;
-}
-
-export type Range = { start: number; end: number };
-
-export interface Region {
-	/** The region's offset from the start of the resource */
-	offset: number;
-
-	/** Ranges cached in this region. These are absolute! */
-	ranges: Range[];
-
-	/** Data for this region */
-	data: Uint8Array;
-}
-
-/**
- * The cache for a specific resource
- * @internal
- */
-export class Resource<ID> {
-	/** Regions used to reduce unneeded allocations. Think of sparse arrays. */
-	public readonly regions: Region[] = [];
-
-	/** The full size of the resource */
-	public get size() {
-		return this._size;
-	}
-
-	public set size(value: number) {
-		if (value >= this._size) {
-			this._size = value;
-			return;
-		}
-
-		this._size = value;
-
-		for (let i = this.regions.length - 1; i >= 0; i--) {
-			const region = this.regions[i];
-
-			if (region.offset >= value) {
-				this.regions.splice(i, 1);
-				continue;
-			}
-
-			const maxLength = value - region.offset;
-			if (region.data.byteLength > maxLength) {
-				region.data = region.data.subarray(0, maxLength);
-			}
-
-			region.ranges = region.ranges
-				.filter(range => range.start < value)
-				.map(range => {
-					if (range.end > value) {
-						return { start: range.start, end: value };
-					}
-					return range;
-				});
-		}
-	}
-
-	public constructor(
-		/** The resource ID */
-		public readonly id: ID,
-		protected _size: number,
-		protected readonly options: Options,
-		resources?: Map<ID, Resource<ID> | undefined>
-	) {
-		options.sparse ??= true;
-		if (!options.sparse) this.regions.push({ offset: 0, data: new Uint8Array(_size), ranges: [] });
-
-		resources?.set(id, this);
-	}
-
-	/** Combines adjacent regions and combines adjacent ranges within a region */
-	public collect(): void {
-		if (!this.options.sparse) return;
-		const { regionGapThreshold = 0xfff } = this.options;
-
-		for (let i = 0; i < this.regions.length - 1; ) {
-			const current = this.regions[i];
-			const next = this.regions[i + 1];
-
-			if (next.offset - (current.offset + current.data.byteLength) > regionGapThreshold) {
-				i++;
-				continue;
-			}
-
-			// Combine ranges
-			current.ranges.push(...next.ranges);
-			current.ranges.sort((a, b) => a.start - b.start);
-
-			// Combine overlapping/adjacent ranges
-			current.ranges = current.ranges.reduce((acc: Range[], range) => {
-				if (!acc.length || acc.at(-1)!.end < range.start) {
-					acc.push(range);
-				} else {
-					acc.at(-1)!.end = Math.max(acc.at(-1)!.end, range.end);
-				}
-				return acc;
-			}, []);
-
-			// Extend buffer to include the new region
-			current.data = extendBuffer(current.data, next.offset + next.data.byteLength);
-			current.data.set(next.data, next.offset - current.offset);
-
-			// Remove the next region after merging
-			this.regions.splice(i + 1, 1);
-		}
-	}
-
-	/** Takes an initial range and finds the sub-ranges that are not in the cache */
-	public missing(start: number, end: number): Range[] {
-		const missingRanges: Range[] = [];
-
-		for (const region of this.regions) {
-			if (region.offset >= end) break;
-
-			for (const range of region.ranges) {
-				if (range.end <= start) continue;
-				if (range.start >= end) break;
-
-				if (range.start > start) {
-					missingRanges.push({ start, end: Math.min(range.start, end) });
-				}
-
-				// Adjust the current start if the region overlaps
-				if (range.end > start) start = Math.max(start, range.end);
-
-				if (start >= end) break;
-			}
-
-			if (start >= end) break;
-		}
-
-		// If there are still missing parts at the end
-		if (start < end) missingRanges.push({ start, end });
-
-		return missingRanges;
-	}
-
-	/**
-	 * Get the cached sub-ranges of an initial range.
-	 * This is conceptually the inverse of `missing`.
-	 */
-	public cached(start: number, end: number): Range[] {
-		const cachedRanges: Range[] = [];
-
-		for (const region of this.regions) {
-			if (region.offset >= end) break;
-
-			for (const range of region.ranges) {
-				if (range.end <= start) continue;
-				if (range.start >= end) break;
-
-				cachedRanges.push({
-					start: Math.max(start, range.start),
-					end: Math.min(end, range.end),
-				});
-			}
-		}
-
-		cachedRanges.sort((a, b) => a.start - b.start);
-		const merged: Range[] = [];
-		for (const curr of cachedRanges) {
-			const last = merged.at(-1);
-			if (last && curr.start <= last.end) {
-				last.end = Math.max(last.end, curr.end);
-			} else {
-				merged.push(curr);
-			}
-		}
-
-		return merged;
-	}
-
-	/** Get the region who's ranges include an offset */
-	public regionAt(offset: number): Region | undefined {
-		if (!this.regions.length) return;
-
-		for (const region of this.regions) {
-			if (region.offset > offset) break;
-
-			// Check if the offset is within this region
-			if (offset >= region.offset && offset < region.offset + region.data.byteLength) return region;
-		}
-	}
-
-	/** Add new data to the cache at given specified offset */
-	public add(data: Uint8Array, offset: number): this {
-		const end = offset + data.byteLength;
-		const region = this.regionAt(offset);
-
-		if (region) {
-			region.data = extendBuffer(region.data, end);
-			region.data.set(data, offset);
-			region.ranges.push({ start: offset, end });
-			region.ranges.sort((a, b) => a.start - b.start);
-
-			this.collect();
-			return this;
-		}
-
-		// Find the correct index to insert the new region
-		const newRegion: Region = { data, offset: offset, ranges: [{ start: offset, end }] };
-		const insertIndex = this.regions.findIndex(region => region.offset > offset);
-
-		// Insert at the right index to keep regions sorted
-		if (insertIndex == -1) {
-			this.regions.push(newRegion); // Append if no later region exists
-		} else {
-			this.regions.splice(insertIndex, 0, newRegion); // Insert before the first region with a greater offset
-		}
-
-		this.collect();
-		return this;
-	}
-}

package/src/checksum.ts

@@ -1,22 +0,0 @@
-/** Utilities for computing checksums */
-
-// Precompute CRC32C table
-const crc32cTable = new Uint32Array(256);
-for (let i = 0; i < 256; i++) {
-	let value = i;
-	for (let j = 0; j < 8; j++) {
-		value = value & 1 ? 0x82f63b78 ^ (value >>> 1) : value >>> 1;
-	}
-	crc32cTable[i] = value;
-}
-
-/**
- * Computes the CRC32C checksum of a Uint8Array.
- */
-export function crc32c(data: Uint8Array): number {
-	let crc = 0xffffffff;
-	for (let i = 0; i < data.length; i++) {
-		crc = (crc >>> 8) ^ crc32cTable[(crc ^ data[i]) & 0xff];
-	}
-	return (crc ^ 0xffffffff) >>> 0;
-}

package/src/debugging.ts

@@ -1,113 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-base-to-string */
-export interface CreateLoggerOptions {
-	/**
-	 * The function used to output
-	 * @default console.log
-	 */
-	output?: (...args: any[]) => void;
-	stringify?: (value: unknown) => string;
-	/**
-	 * Whether to output the class name when logging methods
-	 * @default true
-	 */
-	className?: boolean;
-	/**
-	 * The separator used to separate the class name and method.
-	 * Ignored if `className` is `false`
-	 * @default '#'
-	 */
-	separator?: string;
-	/**
-	 * Whether to log the return value
-	 * @default false
-	 */
-	returnValue?: boolean;
-}
-
-function defaultStringify(value: unknown): string {
-	switch (typeof value) {
-		case 'undefined':
-			return 'undefined';
-		case 'string':
-		case 'number':
-		case 'boolean':
-			return JSON.stringify(value);
-		case 'bigint':
-		case 'symbol':
-			return value.toString();
-		case 'function':
-			return value.name + '()';
-		case 'object':
-			if (value === null) return 'null';
-			if (ArrayBuffer.isView(value)) {
-				const length =
-					'length' in value
-						? (value.length as number)
-						: value.byteLength / (value.constructor as any).BYTES_PER_ELEMENT;
-				return `${value.constructor.name.replaceAll('Array', '').toLowerCase()}[${length}]`;
-			}
-			if (Array.isArray(value)) return `unknown[${value.length}]`;
-			try {
-				const json = JSON.stringify(value);
-
-				return json.length < 100 ? json : value.toString();
-			} catch {
-				return value.toString();
-			}
-	}
-}
-
-type LoggableDecoratorContext = Exclude<DecoratorContext, ClassFieldDecoratorContext>;
-
-/**
- * Create a function that can be used to decorate classes and non-field members.
- */
-export function createLogDecorator(options: CreateLoggerOptions) {
-	const {
-		output = console.log,
-		separator = '#',
-		returnValue = false,
-		stringify = defaultStringify,
-		className = true,
-	} = options;
-
-	return function log<T extends (...args: any[]) => any>(value: T, context: LoggableDecoratorContext): T {
-		if (context.kind == 'class') {
-			return function (...args: any[]) {
-				output(`new ${value.name} (${args.map(stringify).join(', ')})`);
-				return Reflect.construct(value, args);
-			} as T;
-		}
-
-		return function (this: any, ...args: any[]) {
-			const prefix = (className ? this.constructor.name + separator : '') + context.name.toString();
-
-			output(`${prefix}(${args.map(stringify).join(', ')})`);
-
-			const result = value.call(this, ...args);
-
-			if (returnValue) output(' => ' + stringify(result));
-
-			return result;
-		} as T;
-	};
-}
-
-/**
- * @internal @hidden
- */
-export let U_DEBUG = 'process' in globalThis && 'env' in globalThis.process && globalThis.process.env.U_DEBUG == 'true';
-
-/**
- * @internal @hidden
- */
-export function _setDebug(value: boolean) {
-	U_DEBUG = value;
-}
-
-/**
- * @internal @hidden
- */
-export function _debugLog(...text: any[]) {
-	if (U_DEBUG) console.debug('[U]', ...text);
-}

package/src/dom.ts

@@ -1,43 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-
-/**
- * Upload a file
- * @todo use Promise.withResolvers
- */
-export function upload(type?: string, multiple = false): Promise<File> {
-	return new Promise<File>((resolve, reject) => {
-		const input = document.createElement('input');
-		input.type = 'file';
-		if (type) input.accept = type;
-
-		if (multiple) input.multiple = true;
-
-		input.addEventListener('change', e => {
-			const file = input.files?.[0];
-			file ? resolve(file) : reject(new ReferenceError('No files uploaded'));
-		});
-
-		input.click();
-	});
-}
-
-/**
- * Downloads some data
- */
-export function download(data: BlobPart, name: string): void {
-	const link = document.createElement('a');
-	link.href = URL.createObjectURL(new Blob([data]));
-	link.download = name;
-	link.click();
-}
-
-/**
- * Create an instance of a `<template>`
- */
-export function cloneTemplate(selector: string): DocumentFragment {
-	const template = document.querySelector<HTMLTemplateElement>(selector);
-	if (!template) {
-		throw new ReferenceError('Template does not exist: ' + selector);
-	}
-	return template.content.cloneNode(true) as DocumentFragment;
-}

package/src/fs.ts

@@ -1,213 +0,0 @@
-import { isJSON, type JSONValue } from './objects.js';
-import * as fs from 'fs';
-
-export abstract class FileMap<V> implements Map<string, V> {
-	public get [Symbol.toStringTag](): string {
-		return 'FileMap';
-	}
-
-	public constructor(protected readonly path: string) {
-		if (!path) {
-			throw new ReferenceError('No path specified');
-		}
-	}
-
-	protected abstract readonly _map: Map<string, V>;
-
-	public abstract clear(): void;
-
-	public abstract delete(key: string): boolean;
-
-	public abstract get(key: string): V;
-
-	public abstract has(key: string): boolean;
-
-	public abstract set(key: string, value: V): this;
-
-	public get size() {
-		return this._map.size;
-	}
-
-	public get [Symbol.iterator]() {
-		return this._map[Symbol.iterator].bind(this._map);
-	}
-
-	public get keys(): typeof this._map.keys {
-		return this._map.keys.bind(this._map);
-	}
-
-	public get values(): typeof this._map.values {
-		return this._map.values.bind(this._map);
-	}
-
-	public get entries(): typeof this._map.entries {
-		return this._map.entries.bind(this._map);
-	}
-
-	public get forEach(): typeof this._map.forEach {
-		return this._map.forEach.bind(this._map);
-	}
-}
-
-export interface JSONFileMapOptions {
-	/**
-	 * Should an invalid JSON file be overwritten
-	 */
-	overwrite_invalid: boolean;
-}
-
-/**
- * A Map overlaying a JSON file
- */
-export class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
-	public get [Symbol.toStringTag](): 'JSONFileMap' {
-		return 'JSONFileMap';
-	}
-
-	public constructor(
-		path: string,
-		public readonly options: JSONFileMapOptions
-	) {
-		super(path);
-		if (!fs.existsSync(path)) {
-			fs.writeFileSync(path, '{}');
-		}
-	}
-
-	public get _map(): Map<string, T> {
-		const content = fs.readFileSync(this.path, 'utf8');
-		if (!isJSON(content)) {
-			if (!this.options.overwrite_invalid) {
-				throw new SyntaxError('Invalid JSON file: ' + this.path);
-			}
-			console.warn('Invalid JSON file (overwriting): ' + this.path);
-			this.clear();
-			return new Map();
-		}
-		return new Map(Object.entries(JSON.parse(content)));
-	}
-
-	public _write(map: Map<string, T>) {
-		if (!fs.existsSync(this.path)) {
-			fs.writeFileSync(this.path, '{}');
-		}
-		const content = JSON.stringify(Object.fromEntries(map));
-		fs.writeFileSync(this.path, content);
-	}
-
-	public clear() {
-		fs.writeFileSync(this.path, '{}');
-	}
-
-	public delete(key: string): boolean {
-		const map = this._map;
-		const rt = map.delete(key);
-		this._write(map);
-		return rt;
-	}
-
-	public get<U extends T>(key: string): U {
-		return this._map.get(key) as U;
-	}
-
-	public has(key: string): boolean {
-		return this._map.has(key);
-	}
-
-	public set(key: string, value: T): this {
-		const map = this._map;
-		map.set(key, value);
-		this._write(map);
-		return this;
-	}
-}
-
-export interface FolderMapOptions {
-	/**
-	 * Suffix to append to keys to resolve file names
-	 */
-	suffix: string;
-}
-
-/**
- * A Map overlaying a folder
- */
-export class FolderMap extends FileMap<string> {
-	public get [Symbol.toStringTag](): 'FolderMap' {
-		return 'FolderMap';
-	}
-
-	public constructor(
-		path: string,
-		public readonly options: Partial<FolderMapOptions>
-	) {
-		super(path);
-	}
-
-	protected get _names(): string[] {
-		return fs
-			.readdirSync(this.path)
-			.filter(p => p.endsWith(this.options.suffix || ''))
-			.map(p => p.slice(0, -this.options.suffix!.length));
-	}
-
-	protected _join(path: string): string {
-		return `${this.path}/${path}${this.options.suffix}`;
-	}
-
-	protected get _map(): Map<string, string> {
-		const entries: [string, string][] = [];
-		for (const name of this._names) {
-			const content = fs.readFileSync(this._join(name), 'utf8');
-			entries.push([name, content]);
-		}
-		return new Map(entries);
-	}
-
-	public clear(): void {
-		for (const name of this._names) {
-			fs.unlinkSync(this._join(name));
-		}
-	}
-
-	public delete(key: string): boolean {
-		if (!this.has(key)) {
-			return false;
-		}
-
-		fs.unlinkSync(this._join(key));
-		return true;
-	}
-
-	public get(key: string): string {
-		if (!this.has(key)) {
-			throw new ReferenceError('Key not found');
-		}
-		return fs.readFileSync(this._join(key), 'utf8');
-	}
-
-	public has(key: string): boolean {
-		return this._names.includes(key);
-	}
-
-	public set(key: string, value: string): this {
-		fs.writeFileSync(this._join(key), value);
-		return this;
-	}
-}
-
-export function gitCommitHash(repo: string = '.'): string {
-	repo = repo.replaceAll(/\/+/g, '/').replaceAll(/\/$/g, '');
-	const rev = fs
-		.readFileSync(repo + '/.git/HEAD')
-		.toString()
-		.trim();
-	if (rev.indexOf(':') === -1) {
-		return rev;
-	} else {
-		return fs
-			.readFileSync(repo + '/.git/' + rev.substring(5))
-			.toString()
-			.trim();
-	}
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-// 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';
-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';