@gera2ld/common 0.1.1 → 0.1.3

package/dist/base64.d.ts

@@ -0,0 +1,6 @@
+export declare function b64encode(bytes: Uint8Array): string;
+export declare function b64decode(base64: string): Uint8Array<ArrayBuffer>;
+export declare function b64urlEncode(bytes: Uint8Array): string;
+export declare function b64urlDecode(base64url: string): Uint8Array<ArrayBuffer>;
+export declare function encodeText(str: string): Uint8Array<ArrayBuffer>;
+export declare function decodeText(bytes: Uint8Array): string;

package/dist/buffer.d.ts

@@ -0,0 +1,14 @@
+export declare const CrLf: Uint8Array<ArrayBuffer>;
+export declare class BufferReader {
+    private buffer;
+    private requests;
+    isClosed: boolean;
+    read(size?: number): Promise<Uint8Array>;
+    readExact(size: number): Promise<Uint8Array>;
+    readUntil(delimiter?: string | Uint8Array): Promise<Uint8Array>;
+    feed(chunk: Uint8Array): void;
+    close(): void;
+    private processBuffer;
+}
+export declare function concatBuffer(a: Uint8Array, b: Uint8Array): Uint8Array;
+export declare function searchBuffer(buffer: Uint8Array, slice: Uint8Array): number;

package/dist/concurrency.d.ts

@@ -0,0 +1,13 @@
+export declare function limitConcurrency<T extends unknown[], U>(fn: (...args: T) => Promise<U>, concurrency: number): (...args: T) => Promise<U>;
+export declare class Queue<T> {
+    maxSize: number;
+    private data;
+    private getQueue;
+    private putQueue;
+    constructor(maxSize?: number);
+    get size(): number;
+    private defer;
+    private resolve;
+    get(maxWait?: number): Promise<T | undefined>;
+    put(item: T, maxWait?: number): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './base64';
+export * from './buffer';
+export * from './concurrency';
+export * from './logger';
+export * from './number';
+export * from './rate-limiter';
+export * from './request';
+export * from './time';
+export * from './util';

package/dist/index.js

@@ -256,9 +256,29 @@ var P = class {
 	async put(e, t = 0) {
 		this.maxSize && this.data.length >= this.maxSize && await this.defer(this.putQueue, t), this.data.push(e), this.resolve(this.getQueue);
 	}
-}, F = class e {
+}, F = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40
+}, I = {
+	debug: "debug",
+	info: "info",
+	warn: "warn",
+	error: "error"
+};
+function L(e) {
+	return typeof e == "function" ? e() || "" : e || "";
+}
+function R(e, t) {
+	return e && t ? `${e}:${t}` : t || e;
+}
+function z(e, t) {
+	return typeof e == "string" ? w(e, ...t) : w("%o", e, ...t);
+}
+var B = class e {
 	static defaultOptions = {};
-	output;
+	collectors = [];
 	options;
 	constructor(t) {
 		this.options = {
@@ -266,24 +286,79 @@ var P = class {
 			...typeof t == "string" ? { prefix: t } : t
 		};
 	}
+	setOptions(e) {
+		return Object.assign(this.options, e), this;
+	}
+	clone(t) {
+		return new e({
+			...this.options,
+			...t
+		});
+	}
+	child(t) {
+		let n = this.options.prefix, r = new e({
+			...this.options,
+			prefix: () => R(L(n), L(t))
+		});
+		return r.collectors = this.collectors, r;
+	}
 	getPrefix() {
-		let { prefix: e } = this.options;
-		return typeof e == "function" && (e = e()), e || "";
-	}
-	collect() {
-		return this.output = [], () => {
-			let { output: e } = this;
-			if (this.output = void 0, !e) throw Error("Logs already collected");
-			return e;
+		return L(this.options.prefix);
+	}
+	getLevel() {
+		return this.options.level || "debug";
+	}
+	setLevel(e) {
+		return this.setOptions({ level: e });
+	}
+	isEnabledFor(e) {
+		return this.options.enabled !== !1 && F[e] >= F[this.getLevel()];
+	}
+	resolveTimestamp() {
+		let { timestamp: e } = this.options;
+		if (e) return typeof e == "function" ? e() : (/* @__PURE__ */ new Date()).toISOString();
+	}
+	defaultSink(e) {
+		let t = I[e.level];
+		(console[t] || console.log)(...[
+			e.timestamp,
+			e.prefix,
+			e.message
+		].filter(Boolean));
+	}
+	collect(e) {
+		let t = {
+			entries: [],
+			silent: e?.silent
+		};
+		return this.collectors.push(t), () => {
+			let e = this.collectors.indexOf(t);
+			if (e < 0) throw Error("Logs already collected");
+			return this.collectors.splice(e, 1), t.entries;
 		};
 	}
 	log(e, t, ...n) {
-		let r = w(t, ...n);
-		this.output && this.output.push(r), console[e](this.getPrefix(), r);
+		if (!this.isEnabledFor(e)) return;
+		let r = {
+			level: e,
+			prefix: this.getPrefix(),
+			message: z(t, n),
+			timestamp: this.resolveTimestamp(),
+			args: n
+		};
+		for (let e of this.collectors) e.entries.push(r);
+		let i = this.collectors[this.collectors.length - 1];
+		this.options.silent || i?.silent || (this.options.sink ? this.options.sink(r) : this.defaultSink(r));
+	}
+	debug(e, ...t) {
+		return this.log("debug", e, ...t);
 	}
 	info(e, ...t) {
 		return this.log("info", e, ...t);
 	}
+	warn(e, ...t) {
+		return this.log("warn", e, ...t);
+	}
 	error(e, ...t) {
 		return this.log("error", e, ...t);
 	}
@@ -296,13 +371,13 @@ var P = class {
 };
 //#endregion
 //#region src/number.ts
-function I(t, n) {
+function V(t, n) {
 	return BigInt(e(t).multipliedBy(e(10).exponentiatedBy(n)).toFixed(0));
 }
-function L(t, n) {
+function H(t, n) {
 	return e(t).dividedBy(e(10).exponentiatedBy(n)).toNumber();
 }
-var R = {
+var U = {
 	maximumFractionDigits: 4,
 	exponentialThresholdLarge: 1e6,
 	exponentialThresholdSmall: 1e-6,
@@ -311,12 +386,12 @@ var R = {
 	quantizationStep: 0,
 	keepTrailingZeros: !1
 };
-function z(e, t) {
+function W(e, t) {
 	if (e == null || e === "") return "";
 	let n = +e;
 	if (Number.isNaN(n)) return "";
 	let r = {
-		...R,
+		...U,
 		...t
 	};
 	r.quantizationStep > 0 && (n = Math.round(n / r.quantizationStep) * r.quantizationStep);
@@ -333,19 +408,19 @@ function z(e, t) {
 	let s = new Intl.NumberFormat("en-US", o).format(n);
 	return !r.keepTrailingZeros && s.includes(".") && (s = s.replace(/\.?0+$/, "")), s;
 }
-function B(e, t) {
-	return z(e * 100, t) + "%";
+function G(e, t) {
+	return W(e * 100, t) + "%";
 }
 //#endregion
 //#region src/rate-limiter.ts
-var V = {
+var K = {
 	interval: 2e3,
 	maxRetry: 6,
 	maxInterval: 0
 };
-function H(e) {
+function q(e) {
 	let n = {
-		...V,
+		...K,
 		...e
 	}, { interval: r, maxInterval: i } = n;
 	i && i < r && (i = r);
@@ -365,9 +440,9 @@ function H(e) {
 		return a = o.catch(() => {}).then(() => t(r)), o;
 	};
 }
-async function U(e, n) {
+async function J(e, n) {
 	let r = {
-		...V,
+		...K,
 		...n
 	}, { interval: i, maxInterval: a } = r;
 	a && a < i && (a = i);
@@ -377,14 +452,14 @@ async function U(e, n) {
 }
 //#endregion
 //#region src/request.ts
-var W = class extends Error {
+var Y = class extends Error {
 	request;
 	response;
 	constructor(e, t, n, r) {
 		super(e, { cause: r }), this.request = t, this.response = n;
 	}
 };
-function G(e) {
+function X(e) {
 	let t = new URLSearchParams();
 	return Array.isArray(e) || e instanceof URLSearchParams ? new URLSearchParams(e).forEach((e, n) => {
 		t.append(n, e);
@@ -397,11 +472,11 @@ function G(e) {
 		} else t.append(e, n);
 	}), t;
 }
-function K(e, t) {
+function Z(e, t) {
 	let { json: n, timeout: r = 1e4, searchParams: i, signal: a = AbortSignal.timeout(r), ...o } = t || {}, s = new Headers(o.headers);
 	n != null && (o.body = JSON.stringify(n), s.set("content-type", "application/json"));
 	let c = new URL(e);
-	i && (c.search = G(i).toString());
+	i && (c.search = X(i).toString());
 	async function l(e) {
 		let n;
 		try {
@@ -411,14 +486,14 @@ function K(e, t) {
 				signal: a
 			});
 			let r = await e(n);
-			if (!n.ok) throw new W(n.statusText, {
+			if (!n.ok) throw new Y(n.statusText, {
 				url: c.toString(),
 				method: o.method || "GET",
 				options: t
 			}, n, r);
 			return r;
 		} catch (e) {
-			throw e instanceof W ? e : new W(e?.message || `${e}`, {
+			throw e instanceof Y ? e : new Y(e?.message || `${e}`, {
 				url: c.toString(),
 				method: o.method || "GET",
 				options: t
@@ -442,7 +517,7 @@ function K(e, t) {
 }
 //#endregion
 //#region src/time.ts
-var q = [
+var Q = [
 	["ms", 1],
 	["s", 1e3],
 	["m", 60],
@@ -450,7 +525,7 @@ var q = [
 	["d", 24],
 	["mo", 30],
 	["y", 365 / 30]
-], J = [
+], $ = [
 	["year", 365 * 24 * 60 * 60 * 1e3],
 	["month", 720 * 60 * 60 * 1e3],
 	["week", 10080 * 60 * 1e3],
@@ -459,10 +534,10 @@ var q = [
 	["minute", 60 * 1e3],
 	["second", 1e3]
 ];
-function Y(e) {
+function ee(e) {
 	let t = `${e}`.match(/[a-zA-Z]+$/)?.[0] || "", n = t ? +`${e}`.slice(0, -t.length) : +e;
 	if (t) {
-		for (let [e, r] of q) if (n *= r, e === t) {
+		for (let [e, r] of Q) if (n *= r, e === t) {
 			t = "";
 			break;
 		}
@@ -470,9 +545,9 @@ function Y(e) {
 	if (t || isNaN(n)) throw Error(`Invalid interval: ${e}`);
 	return n;
 }
-function X(e, t) {
+function te(e, t) {
 	let { locale: n, style: r = "long" } = t ?? {}, i = Math.abs(e);
-	for (let [e, t] of J) if (i >= t) return new Intl.NumberFormat(n, {
+	for (let [e, t] of $) if (i >= t) return new Intl.NumberFormat(n, {
 		style: "unit",
 		unit: e,
 		unitDisplay: r
@@ -483,22 +558,22 @@ function X(e, t) {
 		unitDisplay: r
 	}).format(Math.round(i / 1e3));
 }
-function Z(e) {
+function ne(e) {
 	return [
 		e.getFullYear(),
 		e.getMonth() + 1,
 		e.getDate()
 	].map((e) => `${e}`.padStart(2, "0")).join("-");
 }
-function Q(e) {
+function re(e) {
 	return new Intl.DateTimeFormat("en-GB", {
 		dateStyle: "short",
 		timeStyle: "medium"
 	}).format(new Date(e));
 }
-function $(e, t) {
+function ie(e, t) {
 	let n = new Date(e).getTime() - Date.now(), r = Math.abs(n), { locale: i, numeric: a = "auto", style: o = "long" } = t ?? {};
-	for (let [e, t] of J) if (r >= t) return new Intl.RelativeTimeFormat(i, {
+	for (let [e, t] of $) if (r >= t) return new Intl.RelativeTimeFormat(i, {
 		numeric: a,
 		style: o
 	}).format(Math.round(n / t), e);
@@ -508,4 +583,4 @@ function $(e, t) {
 	}).format(Math.round(n / 1e3), "second");
 }
 //#endregion
-export { A as BufferReader, k as CrLf, F as Logger, P as Queue, W as SimpleRequestError, h as b64decode, m as b64encode, _ as b64urlDecode, g as b64urlEncode, G as buildSearchParams, D as bytesToHex, j as concatBuffer, y as decodeText, T as defer, L as deflateNumber, v as encodeText, X as formatDuration, Z as formatISODate, z as formatNumber, B as formatPercentage, w as formatString, I as inflateNumber, N as limitConcurrency, O as loadJS, Y as normalizeInterval, H as rateLimiter, b as replacerBigInt, Q as reprDate, C as reprJson, M as searchBuffer, K as simpleRequest, $ as timeAgo, S as truncateString, U as waitUntil, E as wrapFunction };
+export { A as BufferReader, k as CrLf, B as Logger, P as Queue, Y as SimpleRequestError, h as b64decode, m as b64encode, _ as b64urlDecode, g as b64urlEncode, X as buildSearchParams, D as bytesToHex, j as concatBuffer, y as decodeText, T as defer, H as deflateNumber, v as encodeText, te as formatDuration, ne as formatISODate, W as formatNumber, G as formatPercentage, w as formatString, V as inflateNumber, N as limitConcurrency, O as loadJS, ee as normalizeInterval, q as rateLimiter, b as replacerBigInt, re as reprDate, C as reprJson, M as searchBuffer, Z as simpleRequest, ie as timeAgo, S as truncateString, J as waitUntil, E as wrapFunction };

package/dist/logger.d.ts

@@ -0,0 +1,63 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    prefix: string;
+    message: string;
+    timestamp?: string;
+    /** Raw args passed to the log call, useful for custom sinks. */
+    args: unknown[];
+}
+export interface LoggerOptions {
+    prefix?: string | (() => string);
+    /** Minimum level to emit. Defaults to 'debug'. */
+    level?: LogLevel;
+    /** When false, nothing is emitted or collected. Defaults to true. */
+    enabled?: boolean;
+    /** When true, console/sink output is skipped but collectors still capture. */
+    silent?: boolean;
+    /** Include timestamp in entries. `true` uses `toISOString()`. */
+    timestamp?: boolean | (() => string);
+    /**
+     * Custom output. Replaces the default console output.
+     * Useful for file/memory/remote outputs or adapters like
+     * `entry => pino[entry.level](entry.message)`.
+     */
+    sink?: (entry: LogEntry) => void;
+}
+/** @deprecated Use `LoggerOptions` instead. */
+export type ILoggerOptions = LoggerOptions;
+export declare class Logger {
+    static defaultOptions: LoggerOptions;
+    private collectors;
+    options: LoggerOptions;
+    constructor(opts?: string | Partial<LoggerOptions>);
+    /** Update options in place. Returns `this` for chaining. */
+    setOptions(patch: Partial<LoggerOptions>): this;
+    /** Copy this logger, optionally overriding options. Collectors are not shared. */
+    clone(extra?: Partial<LoggerOptions>): Logger;
+    /**
+     * Create a sub-logger with an extended prefix.
+     * Collectors are shared so `parent.collect()` also captures child logs.
+     */
+    child(prefix: string | (() => string)): Logger;
+    getPrefix(): string;
+    getLevel(): LogLevel;
+    setLevel(level: LogLevel): this;
+    isEnabledFor(level: LogLevel): boolean;
+    private resolveTimestamp;
+    private defaultSink;
+    /**
+     * Capture subsequent `LogEntry` objects.
+     * Supports nesting; each call gets its own buffer.
+     * With `{ silent: true }`, console/sink output is suppressed while capturing.
+     */
+    collect(opts?: {
+        silent?: boolean;
+    }): () => LogEntry[];
+    log(level: LogLevel, pattern: unknown, ...args: unknown[]): void;
+    debug(pattern: unknown, ...args: unknown[]): void;
+    info(pattern: unknown, ...args: unknown[]): void;
+    warn(pattern: unknown, ...args: unknown[]): void;
+    error(pattern: unknown, ...args: unknown[]): void;
+    wrap<U extends unknown[], V, T>(fn: (this: T, ...args: U) => V, wrapper: (logger: Logger, fn: (this: T, ...args: U) => V, ...args: U) => V): (this: T, ...args: U) => V;
+}

package/dist/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/number.d.ts

@@ -0,0 +1,41 @@
+export declare function inflateNumber(input: number | string, decimals: number): bigint;
+export declare function deflateNumber(input: number | string | bigint, decimals: number): number;
+export interface INumberOptions {
+    /**
+     * Maximum digits after the decimal point in fixed-point notation.
+     * `1.2345` with `2` becomes `1.23`.
+     */
+    maximumFractionDigits: number;
+    /**
+     * Absolute value threshold for switching to exponential notation for large numbers.
+     * `12345678`>\`1e6` becomes `1.23456e+7`.
+     */
+    exponentialThresholdLarge: number;
+    /**
+     * Absolute value threshold for switching to exponential notation for small non-zero numbers.
+     * `0.000000123`<\`1e-6` becomes `1.23e-7`.
+     */
+    exponentialThresholdSmall: number;
+    /**
+     * Minimum number of significant digits to display.
+     * `12` with `3` becomes `12.00`.
+     */
+    minimumSignificantDigits: number;
+    /**
+     * Maximum number of significant digits to display.
+     * `123456789` with `5` might become `1.2346e+8`.
+     */
+    maximumSignificantDigits: number;
+    /**
+     * Rounds the numerical value to the nearest multiple of this step *before* formatting.
+     * `123456` with `100` becomes `123400` then formatted.
+     */
+    quantizationStep: number;
+    /**
+     * Whether to keep trailing zeros in the fractional part of a number.
+     * e.g. `1.200` becomes `1.2` if false.
+     */
+    keepTrailingZeros?: boolean;
+}
+export declare function formatNumber(num?: number | string, options?: Partial<INumberOptions>): string;
+export declare function formatPercentage(value: number, options?: Partial<INumberOptions>): string;

package/dist/number.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rate-limiter.d.ts

@@ -0,0 +1,17 @@
+export interface IRetryOptions {
+    interval: number;
+    maxRetry: number;
+    maxInterval: number;
+}
+export interface IRateLimitOptions extends IRetryOptions {
+    isTooFrequent?: (error: any) => boolean;
+    onScheduleRetry?: (interval: number) => void;
+}
+export declare function rateLimiter(options?: Partial<IRateLimitOptions>): <U>(fn: () => Promise<U>) => Promise<U>;
+export interface IWaitResult<T = unknown> {
+    interval?: number;
+    error?: unknown;
+    ok: boolean;
+    data: T;
+}
+export declare function waitUntil<T = unknown>(fn: () => Promise<IWaitResult<T>>, options?: IRetryOptions): Promise<IWaitResult<T>>;

package/dist/request.d.ts

@@ -0,0 +1,25 @@
+export type IRequestOptions = RequestInit & {
+    json?: unknown;
+    timeout?: number;
+    searchParams?: string[][] | Record<string, any> | URLSearchParams;
+};
+export declare class SimpleRequestError extends Error {
+    request: {
+        url: string;
+        method: string;
+        options?: IRequestOptions;
+    };
+    response?: Response | undefined;
+    constructor(message: string, request: {
+        url: string;
+        method: string;
+        options?: IRequestOptions;
+    }, response?: Response | undefined, cause?: unknown);
+}
+export declare function buildSearchParams(init?: IRequestOptions["searchParams"]): URLSearchParams;
+export declare function simpleRequest<T = unknown>(url: string | URL, options?: IRequestOptions): {
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    json<U = T>(): Promise<U>;
+    text(): Promise<string>;
+};

package/dist/request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/time.d.ts

@@ -0,0 +1,17 @@
+/** Converts a string like "1h" or a number to milliseconds. */
+export declare function normalizeInterval(interval: string | number): number;
+/** Formats a signed ms duration as a locale-aware string. */
+export declare function formatDuration(ms: number, options?: {
+    locale?: string;
+    style?: "long" | "short" | "narrow";
+}): string;
+/** Formats a Date as "YYYY-MM-DD". */
+export declare function formatISODate(date: Date): string;
+/** Formats a date using Intl.DateTimeFormat with en-GB short date and medium time. */
+export declare function reprDate(date: number | string | Date): string;
+/** Formats a date as a relative time string like "2 hours ago". */
+export declare function timeAgo(date: number | string | Date, options?: {
+    locale?: string;
+    numeric?: "auto" | "always";
+    style?: "long" | "short" | "narrow";
+}): string;

package/dist/time.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,21 @@
+export declare function replacerBigInt(_key: string, value: any): any;
+interface ReprJsonOptions {
+    truncateThreshold: number;
+    headLength: number;
+    tailLength: number;
+}
+export declare function truncateString(input: string, options?: Partial<ReprJsonOptions>): string;
+export declare function reprJson(obj: unknown, options?: Partial<ReprJsonOptions>): string;
+export declare function formatString(fmt: string, ...args: unknown[]): string;
+export interface IDeferred<T> {
+    promise: Promise<T>;
+    resolve: (result: T | Promise<T>) => void;
+    reject: (reason?: any) => void;
+    status: 'pending' | 'resolved' | 'rejected';
+}
+export declare function defer<T = void>(): IDeferred<T>;
+type IFunction<U extends any[], V, T> = (this: T, ...args: U) => V;
+export declare function wrapFunction<U extends any[], V, T>(fn: IFunction<U, V, T>, wrapper: (this: T, originalFn: IFunction<U, V, T>, ...args: U) => V): (this: T, ...args: U) => V;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function loadJS(url: string): Promise<unknown>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gera2ld/common",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -24,6 +24,6 @@
     "clean": "del-cli dist tsconfig.tsbuildinfo",
     "build:types": "tsc",
     "build:js": "vite build",
-    "build": "pnpm run clean && pnpm run /^build:/"
+    "build": "pnpm clean && pnpm build:js && pnpm build:types"
   }
 }