hanzio 1.0.0

package/dist/jwt/index.d.ts

@@ -0,0 +1,3 @@
+import * as jose from 'jose';
+export declare function jwtSign<_Payload extends object>(payload: jose.JWTPayload, secret: string): Promise<string>;
+export declare function jwtVerify<Payload extends object>(token: string, secret: string): Promise<Payload | null>;

package/dist/jwt/index.js

@@ -0,0 +1,19 @@
+// src/jwt/index.ts
+import * as jose from "jose";
+async function jwtSign(payload, secret) {
+  const secretKey = new TextEncoder().encode(secret);
+  return await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().sign(secretKey);
+}
+async function jwtVerify2(token, secret) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await jose.jwtVerify(token, secretKey);
+    return payload;
+  } catch (_error) {
+    return null;
+  }
+}
+export {
+  jwtVerify2 as jwtVerify,
+  jwtSign
+};

package/dist/math/index.d.ts

@@ -0,0 +1,2 @@
+export { linearRegressionTrend } from './linearRegressionTrend';
+export { createResolveColorsByKeys, getHeatmapCellStyle, hashStringToColorIndex, METRICS_SERIES_PALETTE_SIZE, type ResolveColorsByKeysResult, resolveSeriesColorMap, seriesColorKey, withAlpha } from './metricsSeriesColors';

package/dist/math/linearRegressionTrend.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 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.
+ */
+export declare function linearRegressionTrend(values: number[]): number[];

package/dist/math/metricsSeriesColors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared metrics chart series color assignment for web (CSS tokens) and Expo (hex palette).
+ * Same hash + collision strategy so labels map to the same slot index everywhere.
+ */
+/** Matches PrimeVue semantic palette slot count (cyan…blue) and Expo SERIES_COLORS length */
+export declare const METRICS_SERIES_PALETTE_SIZE = 10;
+/**
+ * FNV-1a 32-bit hash — stable palette index for a string key.
+ */
+export declare function hashStringToColorIndex(str: string): number;
+/**
+ * Prefer human-visible label so charts and tables agree on the same color key.
+ */
+export declare function seriesColorKey(label: string | undefined, key: string): string;
+/**
+ * Map each distinct key to a palette index (hash preference, then max-min circular spacing).
+ */
+export declare function resolveSeriesColorMap(keys: string[]): Map<string, number>;
+export type ResolveColorsByKeysResult = {
+    getColor: (key: string) => string;
+    getHoverColor: (key: string) => string;
+};
+/**
+ * Resolve stable colors per key using palette index → RGB/CSS from the caller.
+ */
+export declare function createResolveColorsByKeys(keys: string[], getSeriesColor: (index: number) => string, getSeriesHoverColor: (index: number) => string): ResolveColorsByKeysResult;
+/**
+ * Add alpha to hex, rgb(), or rgba() strings.
+ */
+export declare function withAlpha(color: string, alpha: number): string;
+/**
+ * Heatmap cell background from normalized value intensity.
+ */
+export declare function getHeatmapCellStyle(params: {
+    value: number | null | undefined;
+    min: number;
+    max: number;
+    baseColor: string;
+    neutralColor?: string;
+    minAlpha?: number;
+    maxAlpha?: number;
+}): Record<string, string>;

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

@@ -0,0 +1,95 @@
+export type RunFunction = () => Promise<unknown> | unknown;
+export type Queue<Element, Options> = {
+    size: number;
+    filter: (options: Readonly<Partial<Options>>) => Element[];
+    dequeue: () => Element | undefined;
+    enqueue: (run: Element, options?: Partial<Options>) => void;
+    setPriority: (id: string, priority: number) => void;
+    remove?: (id: string) => void;
+};
+export type TaskOptions = {
+    readonly signal?: AbortSignal | undefined;
+};
+type TimeoutOptions = {
+    timeout?: number;
+};
+export type QueueAddOptions = {
+    readonly priority?: number;
+    id?: string;
+} & TaskOptions & TimeoutOptions;
+export type Options<QueueType extends Queue<RunFunction, QueueOptions> = PriorityQueue, QueueOptions extends QueueAddOptions = QueueAddOptions> = {
+    readonly concurrency?: number;
+    readonly autoStart?: boolean;
+    readonly queueClass?: new () => QueueType;
+    readonly intervalCap?: number;
+    readonly interval?: number;
+    readonly carryoverIntervalCount?: boolean;
+    readonly carryoverConcurrencyCount?: boolean;
+    readonly strict?: boolean;
+} & TimeoutOptions;
+type Task<TaskResultType> = ((options: TaskOptions) => PromiseLike<TaskResultType>) | ((options: TaskOptions) => TaskResultType);
+type EventMap = {
+    active: [];
+    idle: [];
+    empty: [];
+    add: [];
+    next: [];
+    completed: [unknown];
+    error: [unknown];
+    pendingZero: [];
+    rateLimit: [];
+    rateLimitCleared: [];
+};
+type EventName = keyof EventMap;
+type Listener<Event extends EventName> = (...arguments_: EventMap[Event]) => void;
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+export type PriorityQueueOptions = {
+    priority?: number;
+} & QueueAddOptions;
+export declare class PriorityQueue implements Queue<RunFunction, PriorityQueueOptions> {
+    #private;
+    enqueue(run: RunFunction, options?: Partial<PriorityQueueOptions>): void;
+    dequeue(): RunFunction | undefined;
+    filter(options: Readonly<Partial<PriorityQueueOptions>>): RunFunction[];
+    setPriority(id: string, priority: number): void;
+    remove(id: string): void;
+    get size(): number;
+}
+export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsType> = PriorityQueue, EnqueueOptionsType extends QueueAddOptions = QueueAddOptions> {
+    #private;
+    timeout?: number;
+    constructor(options?: Options<QueueType, EnqueueOptionsType>);
+    on<Event extends EventName>(event: Event, listener: Listener<Event>): this;
+    off<Event extends EventName>(event: Event, listener: Listener<Event>): this;
+    emit<Event extends EventName>(event: Event, ...arguments_: EventMap[Event]): boolean;
+    get concurrency(): number;
+    set concurrency(newConcurrency: number);
+    get size(): number;
+    sizeBy(options: Readonly<Partial<EnqueueOptionsType>>): number;
+    get pending(): number;
+    get isPaused(): boolean;
+    get isRateLimited(): boolean;
+    get isSaturated(): boolean;
+    get runningTasks(): ReadonlyArray<{
+        readonly id?: string;
+        readonly priority: number;
+        readonly startTime: number;
+        readonly timeout?: number;
+    }>;
+    setPriority(id: string, priority: number): void;
+    add<TaskResultType>(function_: Task<TaskResultType>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultType>;
+    addAll<TaskResultsType>(functions: ReadonlyArray<Task<TaskResultsType>>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultsType[]>;
+    start(): this;
+    pause(): void;
+    clear(): void;
+    onEmpty(): Promise<void>;
+    onIdle(): Promise<void>;
+    onPendingZero(): Promise<void>;
+    onRateLimit(): Promise<void>;
+    onRateLimitCleared(): Promise<void>;
+    onError(): Promise<never>;
+    onSizeLessThan(limit: number): Promise<void>;
+}
+export {};

package/dist/p-queue/index.js

@@ -0,0 +1,439 @@
+// src/p-queue/index.ts
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+class PriorityQueue {
+  #queue = [];
+  enqueue(run, options = {}) {
+    const element = {
+      priority: options.priority ?? 0,
+      id: options.id,
+      run
+    };
+    const index = this.#queue.findIndex((item) => item.priority < element.priority);
+    if (index === -1) {
+      this.#queue.push(element);
+      return;
+    }
+    this.#queue.splice(index, 0, element);
+  }
+  dequeue() {
+    return this.#queue.shift()?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((item) => Object.entries(options).every(([key, value]) => item[key] === value)).map((item) => item.run);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((item2) => item2.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { ...item, priority });
+  }
+  remove(id) {
+    const index = this.#queue.findIndex((item) => item.id === id);
+    if (index !== -1) {
+      this.#queue.splice(index, 1);
+    }
+  }
+  get size() {
+    return this.#queue.length;
+  }
+}
+
+class PQueue {
+  #listeners = new Map;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  #concurrency;
+  #isPaused;
+  #intervalCap;
+  #interval;
+  #carryoverIntervalCount;
+  #strict;
+  #intervalCount = 0;
+  #intervalEnd = 0;
+  #intervalTimer;
+  #strictTimestamps = [];
+  #rateLimited = false;
+  #idCounter = 1n;
+  #runningTasks = new Map;
+  timeout;
+  constructor(options = {}) {
+    const {
+      concurrency = Number.POSITIVE_INFINITY,
+      autoStart = true,
+      queueClass = PriorityQueue,
+      intervalCap = Number.POSITIVE_INFINITY,
+      interval = 0,
+      carryoverIntervalCount,
+      carryoverConcurrencyCount,
+      strict = false,
+      timeout
+    } = options;
+    if (!(typeof concurrency === "number" && concurrency >= 1)) {
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    }
+    if (!(typeof intervalCap === "number" && intervalCap >= 1)) {
+      throw new TypeError("Expected `intervalCap` to be a number from 1 and up");
+    }
+    if (!(typeof interval === "number" && Number.isFinite(interval) && interval >= 0)) {
+      throw new TypeError("Expected `interval` to be a finite number >= 0");
+    }
+    if (strict && interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (strict && intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
+    if (timeout !== undefined && !(Number.isFinite(timeout) && timeout > 0)) {
+      throw new TypeError("Expected `timeout` to be a positive finite number");
+    }
+    this.#queueClass = queueClass;
+    this.#queue = new queueClass;
+    this.#concurrency = concurrency;
+    this.#isPaused = !autoStart;
+    this.#intervalCap = intervalCap;
+    this.#interval = interval;
+    this.#carryoverIntervalCount = carryoverIntervalCount ?? carryoverConcurrencyCount ?? false;
+    this.#strict = strict;
+    this.timeout = timeout;
+  }
+  on(event, listener) {
+    const listeners = this.#listeners.get(event) ?? new Set;
+    listeners.add(listener);
+    this.#listeners.set(event, listeners);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...arguments_) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners || listeners.size === 0) {
+      return false;
+    }
+    for (const listener of [...listeners]) {
+      listener(...arguments_);
+    }
+    return true;
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  get size() {
+    return this.#queue.size;
+  }
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get isPaused() {
+    return this.#isPaused;
+  }
+  get isRateLimited() {
+    this.#updateRateLimitState();
+    return this.#rateLimited;
+  }
+  get isSaturated() {
+    return this.#pending >= this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
+  setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError("Expected `priority` to be a finite number");
+    }
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    const taskOptions = {
+      timeout: this.timeout,
+      ...options,
+      id: options.id ?? (this.#idCounter++).toString()
+    };
+    return new Promise((resolve, reject) => {
+      const taskSymbol = Symbol(taskOptions.id);
+      let didRun = false;
+      let queuedAbortHandler;
+      let runningAbortHandler;
+      const cleanupQueuedAbort = () => {
+        if (queuedAbortHandler) {
+          taskOptions.signal?.removeEventListener("abort", queuedAbortHandler);
+          queuedAbortHandler = undefined;
+        }
+      };
+      const run = async () => {
+        didRun = true;
+        cleanupQueuedAbort();
+        this.#pending++;
+        this.#runningTasks.set(taskSymbol, {
+          id: taskOptions.id,
+          priority: taskOptions.priority ?? 0,
+          startTime: Date.now(),
+          timeout: taskOptions.timeout
+        });
+        try {
+          taskOptions.signal?.throwIfAborted();
+          const operation = Promise.resolve(function_({ signal: taskOptions.signal }));
+          const result = await this.#withTimeoutAndAbort(operation, taskOptions, (listener) => {
+            runningAbortHandler = listener;
+          });
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          if (runningAbortHandler) {
+            taskOptions.signal?.removeEventListener("abort", runningAbortHandler);
+          }
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
+        }
+      };
+      if (taskOptions.signal?.aborted) {
+        reject(taskOptions.signal.reason);
+        return;
+      }
+      if (taskOptions.signal) {
+        queuedAbortHandler = () => {
+          if (didRun) {
+            return;
+          }
+          this.#queue.remove?.(taskOptions.id);
+          reject(taskOptions.signal?.reason);
+          this.emit("next");
+          this.#tryToStartAnother();
+        };
+        taskOptions.signal.addEventListener("abort", queuedAbortHandler, {
+          once: true
+        });
+      }
+      this.#queue.enqueue(run, taskOptions);
+      this.emit("add");
+      this.#processQueue();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  pause() {
+    this.#isPaused = true;
+  }
+  clear() {
+    this.#queue = new this.#queueClass;
+    this.#clearIntervalTimer();
+    this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.emit("idle");
+    }
+    this.emit("next");
+  }
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  async onIdle() {
+    if (this.#queue.size === 0 && this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  onError() {
+    return new Promise((_resolve, reject) => {
+      const listener = (error) => {
+        this.off("error", listener);
+        reject(error);
+      };
+      this.on("error", listener);
+    });
+  }
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  async#onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  async#withTimeoutAndAbort(operation, options, setAbortListener) {
+    const races = [operation];
+    let timeoutId;
+    if (options.timeout) {
+      races.push(new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new TimeoutError(`Task timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }));
+    }
+    if (options.signal) {
+      races.push(new Promise((_resolve, reject) => {
+        const listener = () => {
+          reject(options.signal?.reason);
+        };
+        setAbortListener(listener);
+        options.signal?.addEventListener("abort", listener, { once: true });
+      }));
+    }
+    try {
+      return await Promise.race(races);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#processQueue();
+    this.emit("next");
+  }
+  #processQueue() {
+    while (this.#tryToStartAnother()) {}
+    this.#updateRateLimitState();
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (this.#isPaused || this.#pending >= this.#concurrency || !this.#doesIntervalAllowAnother()) {
+      return false;
+    }
+    const job = this.#queue.dequeue();
+    if (!job) {
+      return false;
+    }
+    this.#consumeIntervalSlot();
+    this.emit("active");
+    job();
+    return true;
+  }
+  #doesIntervalAllowAnother() {
+    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
+      return true;
+    }
+    const now = Date.now();
+    if (this.#strict) {
+      this.#strictTimestamps = this.#strictTimestamps.filter((timestamp) => now - timestamp < this.#interval);
+      if (this.#strictTimestamps.length < this.#intervalCap) {
+        return true;
+      }
+      this.#scheduleIntervalResume(this.#interval - (now - this.#strictTimestamps[0]));
+      return false;
+    }
+    if (this.#intervalEnd === 0 || now >= this.#intervalEnd) {
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      this.#intervalEnd = now + this.#interval;
+    }
+    if (this.#intervalCount < this.#intervalCap) {
+      return true;
+    }
+    this.#scheduleIntervalResume(this.#intervalEnd - now);
+    return false;
+  }
+  #consumeIntervalSlot() {
+    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
+      return;
+    }
+    if (this.#strict) {
+      this.#strictTimestamps.push(Date.now());
+      return;
+    }
+    this.#intervalCount++;
+  }
+  #scheduleIntervalResume(delay) {
+    if (this.#intervalTimer) {
+      return;
+    }
+    this.#intervalTimer = setTimeout(() => {
+      this.#intervalTimer = undefined;
+      this.#processQueue();
+    }, Math.max(0, delay));
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalTimer) {
+      clearTimeout(this.#intervalTimer);
+      this.#intervalTimer = undefined;
+    }
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimited;
+    const isRateLimited = this.#queue.size > 0 && this.#intervalCap !== Number.POSITIVE_INFINITY && this.#interval > 0 && !this.#doesIntervalAllowAnother();
+    this.#rateLimited = isRateLimited;
+    if (previous !== isRateLimited) {
+      this.emit(isRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+}
+export {
+  PQueue as default,
+  TimeoutError,
+  PriorityQueue
+};

package/dist/promise/index.d.ts

@@ -0,0 +1,21 @@
+export type BackgroundPromiseOptions = {
+    onError?: (error: unknown) => void;
+    onSuccess?: () => void;
+    scheduler?: (callback: () => void) => void;
+};
+export type Success<T> = {
+    data: T;
+    error: null;
+};
+export type Failure<E> = {
+    data: null;
+    error: E;
+};
+export type Result<T, E = Error> = Success<T> | 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>>;

package/dist/sitemap/index.d.ts

@@ -0,0 +1,14 @@
+interface SitemapOptions {
+    filterIndexes?: string;
+    concurrency?: number;
+    maxDepth?: number;
+    timeout?: number;
+}
+/**
+ * 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
+ */
+export declare const getDomainSitemap: (domain: string, options?: SitemapOptions) => Promise<string[]>;
+export {};