@gera2ld/common 0.1.1 → 0.1.2

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/logger.d.ts

@@ -0,0 +1,16 @@
+interface ILoggerOptions {
+    prefix?: string | (() => string);
+}
+export declare class Logger {
+    static defaultOptions: ILoggerOptions;
+    private output?;
+    options: ILoggerOptions;
+    constructor(opts?: string | Partial<ILoggerOptions>);
+    getPrefix(): string;
+    collect(): () => string[];
+    log(type: 'info' | 'error', pattern: string, ...args: unknown[]): void;
+    info(pattern: string, ...args: unknown[]): void;
+    error(pattern: string, ...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;
+}
+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.2",
   "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"
   }
 }