hanzio 1.2.0 → 2.1.0

package/dist/jwt/index.d.ts

@@ -1,3 +1,51 @@
+import type { Result } from '../promise';
 export type JWTPayload = Record<string, unknown>;
-export declare function jwtSign<Payload extends JWTPayload>(payload: Payload, secret: string): Promise<string>;
-export declare function jwtVerify<Payload extends JWTPayload>(token: string, secret: string): Promise<Payload | null>;
+export type JwtAlgorithm = 'HS256' | 'HS384' | 'HS512';
+export type JwtHeader = {
+    alg: string;
+    typ?: string;
+} & Record<string, unknown>;
+export type JwtSignOptions = {
+    /** Seconds from now until `exp`. */
+    expiresIn?: number;
+    /** Seconds from now until `nbf`. */
+    notBefore?: number;
+    issuer?: string;
+    audience?: string | string[];
+    /** Default: `'HS256'` */
+    algorithm?: JwtAlgorithm;
+};
+export type JwtVerifyOptions = {
+    /** Clock skew tolerance for `exp`/`nbf`, in seconds. Default: 0 */
+    leewaySec?: number;
+    /** Required `iss` value. */
+    issuer?: string;
+    /** Required `aud` value (matches a string `aud` or an entry of an array `aud`). */
+    audience?: string;
+    /** Accepted header `alg` values. Default: all of HS256/HS384/HS512. */
+    algorithms?: JwtAlgorithm[];
+};
+export type JwtVerifyErrorCode = 'malformed' | 'unsupported_alg' | 'invalid_signature' | 'expired' | 'not_yet_valid' | 'invalid_issuer' | 'invalid_audience';
+export declare class JwtVerifyError extends Error {
+    readonly code: JwtVerifyErrorCode;
+    constructor(code: JwtVerifyErrorCode);
+}
+/**
+ * Signs `payload` as a compact JWS. `iat` is always set to now.
+ * Claims derived from `options` (`exp`, `nbf`, `iss`, `aud`) override the same
+ * claims in `payload`; payload claims are kept when the option is not given.
+ */
+export declare function jwtSign<Payload extends JWTPayload>(payload: Payload, secret: string, options?: JwtSignOptions): Promise<string>;
+/** Verifies a token. Returns `null` for any failure; use `jwtVerifyResult` for the reason. */
+export declare function jwtVerify<Payload extends JWTPayload>(token: string, secret: string, options?: JwtVerifyOptions): Promise<Payload | null>;
+/**
+ * Verifies signature, `exp`/`nbf` and optional `iss`/`aud`.
+ * Token problems are returned as a failed `Result`; configuration problems
+ * (no Web Crypto, empty secret) throw.
+ */
+export declare function jwtVerifyResult<Payload extends JWTPayload>(token: string, secret: string, options?: JwtVerifyOptions): Promise<Result<Payload, JwtVerifyError>>;
+/** Decodes header and payload WITHOUT verifying the signature. Never trust the result for auth. */
+export declare function jwtDecode<Payload extends JWTPayload = JWTPayload>(token: string): {
+    header: JwtHeader;
+    payload: Payload;
+} | null;

package/dist/math/index.d.ts

@@ -1,2 +1,2 @@
-export { linearRegressionTrend } from './linearRegressionTrend';
-export { createResolveColorsByKeys, getHeatmapCellStyle, hashStringToColorIndex, METRICS_SERIES_PALETTE_SIZE, type ResolveColorsByKeysResult, resolveSeriesColorMap, seriesColorKey, withAlpha } from './metricsSeriesColors';
+export { type LinearRegression, linearRegression, linearRegressionTrend } from './linearRegressionTrend';
+export { clamp, lerp, normalize } from './scale';

package/dist/math/linearRegressionTrend.d.ts

@@ -1,5 +1,18 @@
+export type LinearRegression = {
+    slope: number;
+    intercept: number;
+    /** Coefficient of determination (0..1). 1 when all values are equal (exact fit). */
+    r2: number;
+    /** Fitted y for each index. */
+    fitted: number[];
+};
 /**
  * Least-squares linear regression for y at x = 0, 1, …, n − 1.
- * Returns fitted y for each index, or [] if n < 2 or any input is non-finite.
+ * Returns `null` if n < 2 or any input is non-finite.
+ */
+export declare function linearRegression(values: number[]): LinearRegression | null;
+/**
+ * Fitted y for each index of `values` (see `linearRegression`), or [] if n < 2
+ * or any input is non-finite.
  */
 export declare function linearRegressionTrend(values: number[]): number[];

package/dist/math/scale.d.ts

@@ -0,0 +1,8 @@
+export declare function clamp(value: number, min: number, max: number): number;
+/** Linear interpolation: `t = 0` → `start`, `t = 1` → `end`. */
+export declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Position of `value` within `[min, max]` as 0..1 (clamped). Returns 0 when
+ * the range is empty.
+ */
+export declare function normalize(value: number, min: number, max: number): number;

package/dist/object/index.d.ts

@@ -0,0 +1,19 @@
+/** `Object.keys` typed as the object's string keys. */
+export declare function typedKeys<T extends object>(object: T): (keyof T & string)[];
+/** `Object.entries` typed as `[key, value]` pairs per key. */
+export declare function typedEntries<T extends object>(object: T): {
+    [K in keyof T & string]: [K, T[K]];
+}[keyof T & string][];
+/** `Object.fromEntries` typed as `Record<K, V>`. */
+export declare function typedFromEntries<const K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>): Record<K, V>;
+/** Builds a record with one entry per key. */
+export declare function recordFromKeys<const K extends PropertyKey, V>(keys: readonly K[], fn: (key: K) => V): Record<K, V>;
+export declare function mapValues<T extends object, R>(object: T, fn: (value: T[keyof T & string], key: keyof T & string) => R): Record<keyof T & string, R>;
+export declare function pick<T extends object, const K extends keyof T>(object: T, keys: readonly K[]): Pick<T, K>;
+export declare function omit<T extends object, const K extends keyof T>(object: T, keys: readonly K[]): Omit<T, K>;
+type Path = string | readonly (string | number)[];
+/** Reads a nested value by dot path (`a.b.0.c`) or segment array; undefined when missing. */
+export declare function getAtPath(object: unknown, path: Path): unknown;
+/** Writes a nested value in place, creating arrays for numeric segments and objects otherwise. */
+export declare function setAtPath(object: object, path: Path, value: unknown): void;
+export {};

package/dist/p-queue/index.d.ts

@@ -92,4 +92,4 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
     onError(): Promise<never>;
     onSizeLessThan(limit: number): Promise<void>;
 }
-export {};
+export { PQueue };

package/dist/promise/index.d.ts

@@ -4,18 +4,113 @@ export type BackgroundPromiseOptions = {
     scheduler?: (callback: () => void) => void;
 };
 export type Success<T> = {
+    ok: true;
     data: T;
     error: null;
 };
 export type Failure<E> = {
+    ok: false;
     data: null;
     error: E;
 };
 export type Result<T, E = Error> = Success<T> | Failure<E>;
+export declare function ok<T>(data: T): Success<T>;
+export declare function err<E>(error: E): Failure<E>;
 export declare function isSuccess<T, E>(result: Result<T, E>): result is Success<T>;
 export declare function isFailure<T, E>(result: Result<T, E>): result is Failure<E>;
 export declare function unwrapResult<T, E>(result: Result<T, E>): T;
 export declare function backgroundPromise<T>(promiseFactory: () => Promise<T>, options?: BackgroundPromiseOptions): void;
 export declare function backgroundPromiseSync<T>(promiseFactory: () => Promise<T>, options?: BackgroundPromiseOptions): void;
-export declare function promiseTimeout(ms: number): Promise<void>;
-export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+/** Resolves after `ms`; rejects with `signal.reason` if the signal aborts first. */
+export declare function promiseTimeout(ms: number, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+/**
+ * Accepts a promise or a function; sync throws inside the function are
+ * captured too.
+ */
+export declare function tryCatch<T, E = Error>(input: Promise<T> | (() => T | Promise<T>)): Promise<Result<T, E>>;
+export declare class PromiseTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, message?: string);
+}
+/**
+ * Rejects with `PromiseTimeoutError` after `ms`, or with `signal.reason` when
+ * the signal aborts. Pass a function to receive a signal that aborts on
+ * timeout, so the underlying work can stop too.
+ */
+export declare function withTimeout<T>(input: Promise<T> | ((signal: AbortSignal) => Promise<T>), ms: number, options?: {
+    signal?: AbortSignal;
+    message?: string;
+}): Promise<T>;
+export type BackoffOptions = {
+    /** Delay for the first retry (default 300ms). */
+    baseMs?: number;
+    /** Upper bound for any delay (default 30s). */
+    maxMs?: number;
+    /**
+     * `true`/`'full'`: random delay in [0, computed] (default).
+     * `'partial'`: computed plus 0–`jitterRatio` extra (may exceed `maxMs`).
+     */
+    jitter?: boolean | 'full' | 'partial';
+    /** Max extra fraction for `'partial'` jitter (default 0.25). */
+    jitterRatio?: number;
+    /** Source of randomness in [0, 1) (default `Math.random`). */
+    random?: () => number;
+};
+/** Exponential backoff delay for a 1-based retry attempt. */
+export declare function exponentialBackoff(attempt: number, options?: BackoffOptions): number;
+export type RetryOptions = {
+    /** Retries after the first attempt (default 3). */
+    retries?: number;
+    /** Delay before retry `attempt` (1-based). Default: `exponentialBackoff`. */
+    delayMs?: number | ((attempt: number, error: unknown) => number);
+    /** Return false to stop retrying and rethrow (default: always retry). */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
+    signal?: AbortSignal;
+};
+export declare function retry<T>(fn: (context: {
+    attempt: number;
+    signal?: AbortSignal;
+}) => Promise<T> | T, options?: RetryOptions): Promise<T>;
+/** Maps with bounded concurrency; results keep input order. */
+export declare function pMap<T, R>(items: Iterable<T>, fn: (item: T, index: number) => Promise<R> | R, options?: {
+    concurrency?: number;
+    signal?: AbortSignal;
+}): Promise<R[]>;
+/** Starts a clock; call the returned function to read elapsed ms. */
+export declare function startTimer(): () => number;
+/** Runs `fn` and reports how long it took (throws pass through). */
+export declare function timed<T>(fn: () => Promise<T> | T): Promise<{
+    result: T;
+    durationMs: number;
+}>;
+/**
+ * Aborts when any input aborts, with that signal's `reason`. Undefined inputs
+ * are skipped; no inputs gives a signal that never aborts.
+ */
+export declare function anySignal(...signals: (AbortSignal | undefined)[]): AbortSignal;
+/** Aborts with a `TimeoutError` after `ms`, or earlier if `signal` aborts. */
+export declare function timeoutSignal(ms: number, signal?: AbortSignal): AbortSignal;
+/**
+ * Settles like `promise`, but rejects with `signal.reason` as soon as the
+ * signal aborts. The underlying work is not cancelled.
+ */
+export declare function raceAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+export type LatestGuard = {
+    /** Starts a new generation; earlier tokens become stale. */
+    next(): number;
+    isCurrent(token: number): boolean;
+    /** Marks every outstanding token stale. */
+    invalidate(): void;
+    /** Runs `fn` under a new token; stale results and errors become `{ stale: true }`. */
+    run<T>(fn: () => Promise<T> | T): Promise<{
+        stale: true;
+    } | {
+        stale: false;
+        value: T;
+    }>;
+};
+/** Ignores results of async work superseded by a newer call. */
+export declare function createLatestGuard(): LatestGuard;

package/dist/secrets/core.d.ts

@@ -44,4 +44,11 @@ export type SecretSet<K extends string, Parsed = Record<K, string>> = {
     sources: () => Record<K, string>;
     reload: (options?: SecretRequestOptions) => Promise<SecretSet<K, Parsed>>;
 };
+/** A declaration that must be loaded explicitly before its values can be read. */
+export type LazySecretSet<K extends string, Parsed = Record<K, string>> = SecretSet<K, Parsed> & {
+    /** Initialize once. Concurrent calls share a load; use reload to refresh. */
+    load: (options?: SecretRequestOptions) => Promise<LazySecretSet<K, Parsed>>;
+};
+export declare function createSecretSet<const Keys extends readonly string[], Parsed = Record<Keys[number], string>>(keys: Keys, options: CustomLoaderDefineSecretSetOptions<Keys[number], Parsed>, environmentVariables?: EnvironmentVariables): LazySecretSet<Keys[number], Parsed>;
+/** Compatibility API: declares and loads a complete snapshot before returning. */
 export declare function defineSecretSet<const Keys extends readonly string[], Parsed = Record<Keys[number], string>>(keys: Keys, options: CustomLoaderDefineSecretSetOptions<Keys[number], Parsed>, environmentVariables?: EnvironmentVariables): Promise<SecretSet<Keys[number], Parsed>>;

package/dist/secrets/index.d.ts

@@ -1,4 +1,4 @@
-import { type CommonSecretSetOptions, type CustomLoaderDefineSecretSetOptions, type SecretSet } from './core';
+import { type LazySecretSet, type CommonSecretSetOptions, type CustomLoaderDefineSecretSetOptions, type SecretSet } from './core';
 import { type SecretEnvironment } from './environment';
 import { type InfisicalAuthMode } from './infisical';
 import { type InfisicalProjectOptions } from './infisical-config';
@@ -15,4 +15,6 @@ export type InfisicalDefineSecretSetOptions<K extends string = string, Parsed =
 };
 export type DefineSecretSetOptions<K extends string, Parsed = Record<K, string>> = InfisicalDefineSecretSetOptions<K, Parsed> | CustomLoaderDefineSecretSetOptions<K, Parsed>;
 export declare function getSecretEnvironment(): SecretEnvironment;
+export declare function createSecretSet<const Keys extends readonly string[], Parsed = Record<Keys[number], string>>(keys: Keys, options: DefineSecretSetOptions<Keys[number], Parsed>): LazySecretSet<Keys[number], Parsed>;
+/** Compatibility API: load immediately and fail before application startup. */
 export declare function defineSecretSet<const Keys extends readonly string[], Parsed = Record<Keys[number], string>>(keys: Keys, options: DefineSecretSetOptions<Keys[number], Parsed>): Promise<SecretSet<Keys[number], Parsed>>;

package/dist/secrets/public-config.d.ts

@@ -0,0 +1,7 @@
+import type { SecretSet } from './core';
+/**
+ * Read only explicitly listed public values. No process globals, secret loader,
+ * environment writes, or async initialization; safe in frontend tooling.
+ * Validate application-specific formats with your schema after secrets().
+ */
+export declare function readPublicConfig<const Keys extends readonly string[]>(keys: Keys, values: Readonly<Record<string, string | undefined>>): Pick<SecretSet<Keys[number]>, 'secret' | 'secrets'>;

package/dist/secrets/vite.d.ts

@@ -11,3 +11,4 @@ export type ViteSecretSetOptions<K extends string> = {
 };
 export declare function getViteDefine<K extends string>(secretSet: Pick<SecretSet<K, unknown>, 'secrets'>, options?: ViteSecretSetOptions<K>): Record<string, string>;
 export declare function viteSecretSetPlugin<K extends string>(secretSet: Pick<SecretSet<K, unknown>, 'secrets'>, options?: ViteSecretSetOptions<K>): ViteSecretSetPlugin;
+export { readPublicConfig } from './public-config';

package/dist/secrets/worker.d.ts

@@ -1,3 +1,4 @@
 export * from './core';
 export { cloudflareWorkerEnvLoader } from './worker-loader';
 export type { SecretRequestOptions } from './deadline';
+export { readPublicConfig } from './public-config';

package/dist/sitemap/index.d.ts

@@ -1,14 +1,56 @@
-interface SitemapOptions {
-    filterIndexes?: string;
+/** Substring, RegExp, or predicate. */
+export type SitemapUrlFilter = string | RegExp | ((url: string) => boolean);
+export interface SitemapOptions {
+    /** Only follow nested sitemaps (from a `<sitemapindex>`) that match. */
+    filterIndexes?: SitemapUrlFilter;
+    /** Only keep page URLs (from a `<urlset>`) that match. */
+    filterUrls?: SitemapUrlFilter;
     concurrency?: number;
     maxDepth?: number;
+    /** Stop once this many URLs have been collected. */
+    maxUrls?: number;
+    /** Per-request timeout in ms. */
     timeout?: number;
+    userAgent?: string;
+    fetch?: typeof fetch;
+    /** Called for failed robots.txt/sitemap requests. Defaults to `console.warn`. */
+    onError?: (url: string, error: unknown) => void;
+    /** Drop page URLs that robots.txt disallows for `userAgent`. Defaults to `false`. */
+    respectRobots?: boolean;
 }
+/** The robots.txt rules that apply to one user agent. */
+export interface RobotsRules {
+    allow: string[];
+    disallow: string[];
+    /** Every `Sitemap:` line, whatever group it is in. */
+    sitemaps: string[];
+    crawlDelaySec?: number;
+}
+export interface SitemapEntry {
+    loc: string;
+    lastmod?: string;
+}
+/**
+ * Parses robots.txt for one user agent (RFC 9309): the groups naming its
+ * product token (case-insensitive, versions ignored), else the `*` groups.
+ * Several matching groups are merged. Empty `Allow`/`Disallow` values are dropped.
+ */
+export declare function parseRobotsTxt(body: string, userAgent?: string): RobotsRules;
+/**
+ * Whether `url` (absolute, or a path) may be crawled under `rules` (RFC 9309):
+ * the longest matching pattern wins and `Allow` wins a tie. Patterns support
+ * `*` and a trailing `$`, and match the path plus query string.
+ */
+export declare function isAllowedByRobots(rules: Pick<RobotsRules, 'allow' | 'disallow'>, url: string): boolean;
+/**
+ * Gets all entries (`loc` + optional `lastmod`) from a domain by discovering and crawling its sitemaps
+ * @param domain - The root domain (e.g., 'example.com' or 'https://example.com')
+ * @throws When no sitemap can be discovered
+ */
+export declare const getDomainSitemapEntries: (domain: string, options?: SitemapOptions) => Promise<SitemapEntry[]>;
 /**
  * Gets all URLs from a domain by discovering and crawling its sitemaps
- * @param domain - The root domain (e.g., 'https://example.com')
- * @param options - Configuration options for the crawler
- * @returns Promise<string[]> - Array of unique URLs found in the sitemap
+ * @param domain - The root domain (e.g., 'example.com' or 'https://example.com')
+ * @returns Array of unique URLs found in the sitemap
  */
 export declare const getDomainSitemap: (domain: string, options?: SitemapOptions) => Promise<string[]>;
-export {};