hanzio 1.1.0 → 2.0.0

package/dist/src/api-wrapper/testing.js

@@ -0,0 +1,20 @@
+// src/api-wrapper/testing.ts
+function createMockFetch(handler) {
+  const calls = [];
+  const mockFetch = async (input, init) => {
+    const request = input instanceof Request ? new Request(input, init) : new Request(input.toString(), init);
+    calls.push(request.clone());
+    return handler(request, calls.length - 1);
+  };
+  return Object.assign(mockFetch, { calls });
+}
+function jsonResponse(body, init = {}) {
+  return new Response(JSON.stringify(body), {
+    status: init.status ?? 200,
+    headers: { "content-type": "application/json", ...init.headers }
+  });
+}
+export {
+  createMockFetch,
+  jsonResponse
+};

package/dist/{cool-console-log → src/cool-console-log}/index.js

@@ -30,57 +30,103 @@ var terminalColors = {
   bgCyan: "\x1B[46m",
   bgWhite: "\x1B[47m"
 };
+var noColors = Object.fromEntries(Object.keys(terminalColors).map((key) => [key, ""]));
+function getProcessEnvironment() {
+  return typeof process === "undefined" ? undefined : process.env;
+}
+function isDev() {
+  return getProcessEnvironment()?.NODE_ENV !== "production";
+}
+function supportsColor() {
+  const env = getProcessEnvironment();
+  if (!env || env.NO_COLOR)
+    return false;
+  if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "0")
+    return true;
+  return process.stdout?.isTTY === true;
+}
+var levelRank = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
 var levelColors = {
   debug: { badge: terminalColors.gray, text: terminalColors.dim },
   info: { badge: terminalColors.cyan, text: terminalColors.reset },
   warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
   error: { badge: terminalColors.red, text: terminalColors.brightRed }
 };
+function formatValue(value) {
+  if (value instanceof Error)
+    return String(value);
+  if (typeof value !== "object" || value === null)
+    return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch (_error) {
+    return "[Unserializable]";
+  }
+}
 function formatAttributes(attrs) {
   if (!attrs || Object.keys(attrs).length === 0)
     return "";
-  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`).join(" ");
+  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${formatValue(v)}`).join(" ");
   return ` ${formatted}`;
 }
 function createCoolLogger(options = {}) {
-  const { colorsInDevOnly = true, onLog } = options;
-  const isDev = true;
-  const useColors = colorsInDevOnly ? isDev : true;
-  const createLogMethod = (level) => (message, attributes) => {
-    onLog?.(level, message, attributes);
-    if (level === "debug" && !isDev)
-      return;
-    if (useColors) {
-      const { badge, text } = levelColors[level];
-      const label = level.toUpperCase().padEnd(5);
-      const attrStr = formatAttributes(attributes);
-      console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
-    } else {
-      console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
-    }
-  };
-  return {
-    debug: createLogMethod("debug"),
-    info: createLogMethod("info"),
-    warn: createLogMethod("warn"),
-    error: createLogMethod("error")
+  const dev = isDev();
+  const {
+    colorsInDevOnly = true,
+    minLevel = dev ? "debug" : "info",
+    onLog
+  } = options;
+  const useColors = supportsColor() && (!colorsInDevOnly || dev);
+  const createLogger = (base) => {
+    const createLogMethod = (level) => (message, callAttributes) => {
+      const attributes = base && callAttributes ? { ...base, ...callAttributes } : callAttributes ?? base;
+      onLog?.(level, message, attributes);
+      if (levelRank[level] < levelRank[minLevel])
+        return;
+      if (useColors) {
+        const { badge, text } = levelColors[level];
+        const label = level.toUpperCase().padEnd(5);
+        const attrStr = formatAttributes(attributes);
+        console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
+      } else {
+        console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
+      }
+    };
+    return {
+      debug: createLogMethod("debug"),
+      info: createLogMethod("info"),
+      warn: createLogMethod("warn"),
+      error: createLogMethod("error"),
+      child: (attributes) => createLogger({ ...base, ...attributes })
+    };
   };
+  return createLogger();
 }
 function logOperationSummary(operationName, durationMs, success, options = {}) {
   const { devOnly = true, error } = options;
-  const isDev = true;
-  if (devOnly && !isDev)
+  if (devOnly && !isDev())
     return;
-  const c = terminalColors;
+  const c = supportsColor() ? terminalColors : noColors;
   const statusIcon = success ? `${c.brightGreen}✓${c.reset}` : `${c.brightRed}✗${c.reset}`;
   const statusColor = success ? c.green : c.red;
   const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`;
   const errorMessage = error ? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}` : "";
   console.log(`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`);
 }
+function startOperation(operationName, options = {}) {
+  const start = performance.now();
+  return (success = true, error) => logOperationSummary(operationName, performance.now() - start, success, {
+    ...options,
+    error
+  });
+}
 function colorize(text, color, ...modifiers) {
-  const isDev = true;
-  if (!isDev)
+  if (!isDev() || !supportsColor())
     return text;
   const colorCodes = [
     terminalColors[color],
@@ -90,8 +136,7 @@ function colorize(text, color, ...modifiers) {
 }
 function logBanner(text, color = "cyan", options = {}) {
   const { devOnly = true } = options;
-  const isDev = true;
-  if (devOnly && !isDev) {
+  if (devOnly && !isDev() || !supportsColor()) {
     console.log(`=== ${text} ===`);
     return;
   }
@@ -103,9 +148,11 @@ function logBanner(text, color = "cyan", options = {}) {
   console.log(`${c[color]}╚${line}╝${c.reset}`);
 }
 export {
-  terminalColors,
-  logOperationSummary,
-  logBanner,
+  colorize,
   createCoolLogger,
-  colorize
+  logBanner,
+  logOperationSummary,
+  startOperation,
+  supportsColor,
+  terminalColors
 };

package/dist/src/crypto/index.js

@@ -0,0 +1,195 @@
+import {
+  utf8Encode2,
+  utf8Decode2,
+  encodeBase642,
+  decodeBase642,
+  encodeBase64Url2,
+  decodeBase64Url2,
+  bytesToHex2,
+  hexToBytes2,
+  toBytes,
+  safeEqual2,
+  randomBytes2,
+  randomToken2,
+  sha2562,
+  sha256Hex2,
+  hmacSign2,
+  verifyHmacSignature2,
+  getSubtleCrypto
+} from "../../index-rp5pqghz.js";
+// src/crypto/sealer.ts
+var ERROR_MESSAGES = {
+  malformed: "Malformed sealed value",
+  unsupported_version: "Unsupported sealed value version",
+  decrypt_failed: "Could not open sealed value: wrong key or tampered data"
+};
+
+class SealerError extends Error {
+  code;
+  constructor(code) {
+    super(ERROR_MESSAGES[code]);
+    this.name = "SealerError";
+    this.code = code;
+  }
+}
+var PREFIX = "enc:v1:";
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
+var DEFAULT_INFO = "hanzio.sealer.aes-256-gcm.v1";
+function createSealer(options) {
+  const { secret, salt = "", info = DEFAULT_INFO } = options;
+  const secretBytes = toBytes(secret);
+  if (secretBytes.length === 0) {
+    throw new TypeError("Sealer secret must not be empty");
+  }
+  let keyPromise;
+  const getKey = () => {
+    if (!keyPromise) {
+      keyPromise = deriveKey(secretBytes, salt, info);
+      keyPromise.catch(() => {
+        keyPromise = undefined;
+      });
+    }
+    return keyPromise;
+  };
+  const seal = async (plaintext) => {
+    const iv = randomBytes2(IV_BYTES);
+    const encrypted = new Uint8Array(await getSubtleCrypto().encrypt({ name: "AES-GCM", iv }, await getKey(), utf8Encode2(plaintext)));
+    const tagStart = encrypted.length - TAG_BYTES;
+    return `${PREFIX}${encodeBase64Url2(iv)}.${encodeBase64Url2(encrypted.subarray(tagStart))}.${encodeBase64Url2(encrypted.subarray(0, tagStart))}`;
+  };
+  const open = async (sealed) => {
+    if (typeof sealed !== "string" || !sealed.startsWith(PREFIX)) {
+      const isOtherVersion = typeof sealed === "string" && /^enc:v\d+:/.test(sealed);
+      throw new SealerError(isOtherVersion ? "unsupported_version" : "malformed");
+    }
+    const parts = sealed.slice(PREFIX.length).split(".");
+    let iv;
+    let tag;
+    let ciphertext;
+    try {
+      if (parts.length !== 3)
+        throw new Error;
+      iv = decodeBase64Url2(parts[0]);
+      tag = decodeBase64Url2(parts[1]);
+      ciphertext = decodeBase64Url2(parts[2]);
+    } catch (_error) {
+      throw new SealerError("malformed");
+    }
+    if (iv.length !== IV_BYTES || tag.length !== TAG_BYTES) {
+      throw new SealerError("malformed");
+    }
+    const encrypted = new Uint8Array(ciphertext.length + TAG_BYTES);
+    encrypted.set(ciphertext);
+    encrypted.set(tag, ciphertext.length);
+    const key = await getKey();
+    let plaintext;
+    try {
+      plaintext = await getSubtleCrypto().decrypt({ name: "AES-GCM", iv }, key, encrypted);
+    } catch (_error) {
+      throw new SealerError("decrypt_failed");
+    }
+    return utf8Decode2(plaintext);
+  };
+  return {
+    seal,
+    open,
+    async sealJson(value) {
+      const json = JSON.stringify(value);
+      if (json === undefined) {
+        throw new TypeError("sealJson value is not JSON-serializable");
+      }
+      return seal(json);
+    },
+    async openJson(sealed) {
+      return JSON.parse(await open(sealed));
+    }
+  };
+}
+async function deriveKey(secret, salt, info) {
+  const subtle = getSubtleCrypto();
+  const baseKey = await subtle.importKey("raw", secret, "HKDF", false, [
+    "deriveKey"
+  ]);
+  return subtle.deriveKey({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: utf8Encode2(salt),
+    info: utf8Encode2(info)
+  }, baseKey, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+// src/crypto/webhook.ts
+var TIMESTAMP = /^\d+$/;
+async function verifySvixSignature(options) {
+  const {
+    secret,
+    payload,
+    headers,
+    toleranceSec = 300,
+    now = Date.now()
+  } = options;
+  let key;
+  try {
+    key = decodeBase642(secret.startsWith("whsec_") ? secret.slice(6) : secret);
+  } catch (_error) {
+    throw new TypeError("Invalid webhook secret: expected whsec_<base64>");
+  }
+  if (key.length === 0)
+    throw new TypeError("Webhook secret must not be empty");
+  const id = getHeader(headers, "id");
+  const timestamp = getHeader(headers, "timestamp");
+  const signatureHeader = getHeader(headers, "signature");
+  if (!id || !timestamp || !signatureHeader)
+    return false;
+  if (!TIMESTAMP.test(timestamp))
+    return false;
+  if (Math.abs(now / 1000 - Number(timestamp)) > toleranceSec)
+    return false;
+  const expected = await hmacSign2(key, `${id}.${timestamp}.${payload}`, {
+    encoding: "base64"
+  });
+  return signatureHeader.split(" ").some((entry) => {
+    const comma = entry.indexOf(",");
+    if (comma === -1 || entry.slice(0, comma) !== "v1")
+      return false;
+    return safeEqual2(entry.slice(comma + 1), expected);
+  });
+}
+function getHeader(headers, name) {
+  for (const prefix of ["svix-", "webhook-"]) {
+    const value = readHeader(headers, prefix + name);
+    if (value)
+      return value;
+  }
+  return;
+}
+function readHeader(headers, name) {
+  if (typeof headers.get === "function") {
+    return headers.get(name) ?? undefined;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name)
+      return value;
+  }
+  return;
+}
+export {
+  SealerError,
+  bytesToHex2 as bytesToHex,
+  createSealer,
+  decodeBase642 as decodeBase64,
+  decodeBase64Url2 as decodeBase64Url,
+  encodeBase642 as encodeBase64,
+  encodeBase64Url2 as encodeBase64Url,
+  hexToBytes2 as hexToBytes,
+  hmacSign2 as hmacSign,
+  randomBytes2 as randomBytes,
+  randomToken2 as randomToken,
+  safeEqual2 as safeEqual,
+  sha2562 as sha256,
+  sha256Hex2 as sha256Hex,
+  utf8Decode2 as utf8Decode,
+  utf8Encode2 as utf8Encode,
+  verifyHmacSignature2 as verifyHmacSignature,
+  verifySvixSignature
+};

package/dist/src/format/index.js

@@ -0,0 +1,211 @@
+import {
+  stableStringify2
+} from "../../index-kj1phgrx.js";
+
+// src/format/index.ts
+var MAX_CACHED_FORMATTERS = 100;
+function memoize(create) {
+  const cache = new Map;
+  return (locale, options) => {
+    const key = `${locale}|${options ? stableStringify2(options) : ""}`;
+    let formatter = cache.get(key);
+    if (formatter) {
+      cache.delete(key);
+    } else {
+      formatter = create(locale, options);
+      if (cache.size >= MAX_CACHED_FORMATTERS) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+          cache.delete(oldest);
+      }
+    }
+    cache.set(key, formatter);
+    return formatter;
+  };
+}
+var getNumberFormat = memoize((locale, options) => new Intl.NumberFormat(locale, options));
+var getDateTimeFormat = memoize((locale, options) => new Intl.DateTimeFormat(locale, options));
+var getRelativeTimeFormat = memoize((locale, options) => new Intl.RelativeTimeFormat(locale, options));
+var getListFormat = memoize((locale, options) => new Intl.ListFormat(locale, options));
+var getPluralRules = memoize((locale, options) => new Intl.PluralRules(locale, options));
+function toTime(value) {
+  return value instanceof Date ? value.getTime() : new Date(value).getTime();
+}
+function formatNumber(value, locale, options) {
+  return getNumberFormat(locale, options).format(value);
+}
+function formatPercent(value, locale, options) {
+  return formatNumber(value, locale, { ...options, style: "percent" });
+}
+function formatCurrency(amount, currency, locale, options) {
+  return formatNumber(amount, locale, {
+    ...options,
+    style: "currency",
+    currency
+  });
+}
+function formatCompactNumber(value, locale) {
+  return formatNumber(value, locale, { notation: "compact" });
+}
+var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB"];
+function formatBytes(bytes, options = {}) {
+  const { locale = "en-US", decimals, binary = true } = options;
+  const base = binary ? 1024 : 1000;
+  let exponent = 0;
+  while (Math.abs(bytes) >= base ** (exponent + 1) && exponent < BYTE_UNITS.length - 1) {
+    exponent++;
+  }
+  const maximumFractionDigits = exponent === 0 ? 0 : decimals ?? (exponent === 1 ? 0 : 1);
+  const value = formatNumber(bytes / base ** exponent, locale, {
+    maximumFractionDigits
+  });
+  return `${value} ${BYTE_UNITS[exponent]}`;
+}
+var SECOND_MS = 1000;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+function splitDuration(ms) {
+  const total = Number.isFinite(ms) && ms > 0 ? Math.floor(ms) : 0;
+  return {
+    days: Math.floor(total / DAY_MS),
+    hours: Math.floor(total % DAY_MS / HOUR_MS),
+    minutes: Math.floor(total % HOUR_MS / MINUTE_MS),
+    seconds: Math.floor(total % MINUTE_MS / SECOND_MS),
+    milliseconds: total % SECOND_MS
+  };
+}
+function formatClockDuration(ms) {
+  const { days, hours, minutes, seconds } = splitDuration(ms);
+  const totalHours = days * 24 + hours;
+  const pad = (n) => String(n).padStart(2, "0");
+  return totalHours > 0 ? `${totalHours}:${pad(minutes)}:${pad(seconds)}` : `${minutes}:${pad(seconds)}`;
+}
+var DURATION_UNITS = [
+  ["days", "day"],
+  ["hours", "hour"],
+  ["minutes", "minute"],
+  ["seconds", "second"],
+  ["milliseconds", "millisecond"]
+];
+function formatDuration(ms, locale, options = {}) {
+  const { style = "short", maxUnits = 2 } = options;
+  const parts = splitDuration(ms);
+  const unit = (value, name) => formatNumber(value, locale, {
+    style: "unit",
+    unit: name,
+    unitDisplay: style
+  });
+  const first = DURATION_UNITS.findIndex(([key]) => parts[key] > 0);
+  if (first === -1)
+    return unit(0, "second");
+  const shown = DURATION_UNITS.slice(first, first + Math.max(1, maxUnits)).filter(([key]) => parts[key] > 0).map(([key, name]) => unit(parts[key], name));
+  return formatList(shown, locale, { type: "unit", style });
+}
+function relativeUnit(ms) {
+  const seconds = ms / 1000;
+  if (Math.abs(seconds) < 60)
+    return { value: Math.round(seconds), unit: "second" };
+  const minutes = seconds / 60;
+  if (Math.abs(minutes) < 60)
+    return { value: Math.round(minutes), unit: "minute" };
+  const hours = minutes / 60;
+  if (Math.abs(hours) < 24)
+    return { value: Math.round(hours), unit: "hour" };
+  const days = hours / 24;
+  if (Math.abs(days) < 30)
+    return { value: Math.round(days), unit: "day" };
+  const months = days / 30;
+  if (Math.abs(months) < 12)
+    return { value: Math.round(months), unit: "month" };
+  return { value: Math.round(days / 365), unit: "year" };
+}
+function formatRelativeTime(date, locale, options = {}) {
+  const {
+    now = Date.now(),
+    numeric = "auto",
+    style,
+    withSuffix = true
+  } = options;
+  const diff = toTime(date) - toTime(now);
+  if (!Number.isFinite(diff))
+    return "";
+  const { value, unit } = relativeUnit(diff);
+  if (withSuffix) {
+    return getRelativeTimeFormat(locale, { numeric, style }).format(value, unit);
+  }
+  return formatNumber(Math.abs(value), locale, {
+    style: "unit",
+    unit,
+    unitDisplay: style ?? "long"
+  });
+}
+function formatWait(value, locale, options = {}) {
+  const elapsed = typeof value === "number" ? value : toTime(options.now ?? Date.now()) - toTime(value);
+  const waited = Math.max(0, elapsed);
+  if (!Number.isFinite(waited))
+    return "";
+  const [amount, unit] = waited < HOUR_MS ? [Math.max(1, Math.floor(waited / MINUTE_MS)), "minute"] : waited < DAY_MS ? [Math.floor(waited / HOUR_MS), "hour"] : [Math.floor(waited / DAY_MS), "day"];
+  return formatNumber(amount, locale, {
+    style: "unit",
+    unit,
+    unitDisplay: "short"
+  });
+}
+var DATE_COMPONENTS = [
+  "weekday",
+  "era",
+  "year",
+  "month",
+  "day",
+  "dayPeriod",
+  "hour",
+  "minute",
+  "second",
+  "fractionalSecondDigits",
+  "dateStyle",
+  "timeStyle"
+];
+function formatDateRange(start, end, locale, options = {}) {
+  const hasFields = DATE_COMPONENTS.some((key) => options[key] !== undefined);
+  const format = getDateTimeFormat(locale, hasFields ? options : { day: "numeric", month: "short", year: "numeric", ...options });
+  const from = new Date(toTime(start));
+  const to = new Date(toTime(end));
+  return typeof format.formatRange === "function" ? format.formatRange(from, to) : `${format.format(from)} – ${format.format(to)}`;
+}
+function formatList(items, locale, options) {
+  if (typeof Intl.ListFormat !== "function") {
+    return items.join(options?.style === "narrow" ? " " : ", ");
+  }
+  return getListFormat(locale, options).format(items);
+}
+function formatCappedCount(count, max = 99) {
+  if (!(count > 0))
+    return "0";
+  return count > max ? `${max}+` : String(count);
+}
+function pluralize(count, forms, locale) {
+  const form = forms[getPluralRules(locale).select(count)] ?? forms.other;
+  return form.replaceAll("{count}", formatNumber(count, locale));
+}
+export {
+  formatBytes,
+  formatCappedCount,
+  formatClockDuration,
+  formatCompactNumber,
+  formatCurrency,
+  formatDateRange,
+  formatDuration,
+  formatList,
+  formatNumber,
+  formatPercent,
+  formatRelativeTime,
+  formatWait,
+  getDateTimeFormat,
+  getListFormat,
+  getNumberFormat,
+  getPluralRules,
+  getRelativeTimeFormat,
+  pluralize,
+  splitDuration
+};

package/dist/src/i18n/index.js

@@ -0,0 +1,36 @@
+// src/i18n/index.ts
+var PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+function extractPlaceholders(template) {
+  const names = template.matchAll(PLACEHOLDER_PATTERN).map((match) => match[1]);
+  return [...new Set(names)];
+}
+function interpolate(template, ...args) {
+  const params = args[0] ?? {};
+  return template.replace(PLACEHOLDER_PATTERN, (match, name) => {
+    const value = Object.hasOwn(params, name) ? params[name] : undefined;
+    return value == null ? match : String(value);
+  });
+}
+function flattenMessages(messages) {
+  const out = {};
+  const visit = (node, prefix) => {
+    for (const [key, value] of Object.entries(node)) {
+      if (typeof value === "string")
+        out[prefix + key] = value;
+      else
+        visit(value, `${prefix + key}.`);
+    }
+  };
+  visit(messages, "");
+  return out;
+}
+function createTranslator(messages) {
+  const flat = flattenMessages(messages);
+  return (key, ...args) => interpolate(flat[key] ?? key, ...args);
+}
+export {
+  createTranslator,
+  extractPlaceholders,
+  flattenMessages,
+  interpolate
+};