@heyramzi/utils 0.0.0-stage → 1.12.0

package/src/errors/sentry/sveltekit.ts

@@ -0,0 +1,188 @@
+/**
+ * Kit 3 `handleError` hooks over the SDK-free Sentry sender. They read the `kind` field kit 2
+ * never sent. The app passes `dev`, `release` and the DSN, so nothing imports kit.
+ */
+
+import { captureError } from "#src/errors/sentry/index.js";
+import type { SentryScalar } from "#src/errors/sentry/protocol.js";
+
+/** The part of kit's `CaughtError & { event }` these hooks read, so kit's hook types accept ours. */
+export type CaughtInput = {
+  kind: "app" | "framework" | "validation" | "unknown";
+  error: unknown;
+  event: { url: URL; route: { id: string | null } };
+};
+
+type BaseOptions<R> = {
+  /** Public client key on the browser, private on the server. Empty or missing sends nothing. */
+  dsn: string | undefined;
+  /** `dev` from `$app/env`. Reports nothing while true. */
+  dev: boolean;
+  /** `version` from `$app/env`. Set `kit.version.name` to the commit SHA so a fix is traceable. */
+  release: string | undefined;
+  /** Becomes the `surface` tag, e.g. "web.server". */
+  surface: string;
+  /** Defaults to "production". Pass "preview" or "staging" from the app's env where those exist. */
+  environment?: string;
+  tags?: Record<string, SentryScalar | null | undefined>;
+  /** Logs the error to the console before reporting. Pass false when `respond` already logs. */
+  log?: boolean;
+  /**
+   * The user-facing `App.Error`, returned for every caught error, reported or not. Return
+   * nothing to keep kit's defaults. A throw here is logged and kit's defaults apply.
+   */
+  respond?: (input: CaughtInput) => R | Promise<R>;
+};
+
+export type ClientErrorOptions<R> = BaseOptions<R> & {
+  /**
+   * Return true to drop an error. Runs only after the status filter, so an expensive check
+   * (kit's `updated.check()`) isn't paid on a 404.
+   */
+  skip?: (input: CaughtInput) => boolean | Promise<boolean>;
+};
+
+export type ServerErrorOptions<R> = BaseOptions<R>;
+
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+
+/**
+ * Whether a caught error should page us. An `app` error comes from `error()` and is expected.
+ * A framework or validation error counts from 500 up. Anything unknown is a bug.
+ */
+export function shouldReport({ kind, error }: Pick<CaughtInput, "kind" | "error">): boolean {
+  if (kind === "app") return false;
+  if (kind === "unknown") return true;
+  const status = (error as { status?: unknown } | null)?.status;
+  return typeof status === "number" ? status >= 500 : true;
+}
+
+// Chrome, Safari and Firefox each word a dynamic import that 404s differently.
+const STALE_CHUNK =
+  /Failed to fetch dynamically imported module|Importing a module script failed|error loading dynamically imported module/;
+
+/** A dynamic import failed: a deploy removed the chunk this old page points at, or the network dropped. */
+export function isStaleChunk(error: unknown): boolean {
+  const message = (error as { message?: unknown } | null)?.message;
+  return typeof message === "string" && STALE_CHUNK.test(message);
+}
+
+const RELOAD_KEY = "heyramzi:stale-chunk-reload";
+/** A tab left open across two deploys reloads on each. Inside this window a repeat means the reload didn't help. */
+const RELOAD_WINDOW_MS = 30_000;
+
+type ReloadEnv = {
+  storage: Pick<Storage, "getItem" | "setItem">;
+  now: () => number;
+  reload: () => void;
+};
+
+function browserEnv(): ReloadEnv | null {
+  try {
+    return { storage: sessionStorage, now: Date.now, reload: () => location.reload() };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reload once per window to fetch the new build. False when it already did or storage is
+ * blocked, because without the guard a broken chunk loops reloads.
+ */
+export function reloadForStaleChunk(env: ReloadEnv | null = browserEnv()): boolean {
+  if (!env) return false;
+  try {
+    const last = Number(env.storage.getItem(RELOAD_KEY));
+    if (env.now() - last < RELOAD_WINDOW_MS) return false;
+    env.storage.setItem(RELOAD_KEY, String(env.now()));
+    env.reload();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Kit's HttpError isn't an Error, so one with a message becomes one to give Sentry a title and stack. */
+function toError(raw: unknown): unknown {
+  if (raw instanceof Error) return raw;
+  const message = (raw as { message?: unknown } | null)?.message;
+  return typeof message === "string" ? new Error(message) : raw;
+}
+
+function isLocalHost(input: CaughtInput): boolean {
+  return LOCAL_HOSTS.has(input.event.url.hostname);
+}
+
+async function report<R>(
+  options: BaseOptions<R>,
+  input: CaughtInput,
+  extraTags?: Record<string, SentryScalar>,
+): Promise<void> {
+  const { dsn, dev, release, surface, environment = "production", tags } = options;
+  // WHY the host check: wrangler dev and vite preview serve localhost with `dev` false.
+  if (dev || !dsn || isLocalHost(input)) return;
+  await captureError({
+    dsn,
+    error: toError(input.error),
+    surface,
+    release,
+    environment,
+    tags: { ...tags, ...extraTags, route: input.event.route.id },
+    extra: { pathname: input.event.url.pathname, kind: input.kind },
+  });
+}
+
+async function respondTo<R>(options: BaseOptions<R>, input: CaughtInput): Promise<R | undefined> {
+  if (!options.respond) return undefined;
+  try {
+    return await options.respond(input);
+  } catch (err) {
+    console.error("[handleError] respond threw:", err);
+    return undefined;
+  }
+}
+
+/**
+ * `handleError` for `hooks.client.ts`. A stale-chunk error reloads the page once instead
+ * of reporting. Everything else that's ours goes to Sentry, tagged with the environment
+ * and release.
+ */
+export function createHandleClientError<R = undefined>(options: ClientErrorOptions<R>) {
+  return async (input: CaughtInput): Promise<R | undefined> => {
+    try {
+      let tags: Record<string, SentryScalar> | undefined;
+      if (isStaleChunk(input.error)) {
+        if (reloadForStaleChunk()) return respondTo(options, input);
+        // Already reloaded once: report it, tagged so it filters apart from a real bug.
+        tags = { stale_chunk: true };
+      }
+      if (shouldReport(input)) {
+        if (options.log !== false) console.error("[handleError]", input.error);
+        if (!(await options.skip?.(input))) await report(options, input, tags);
+      }
+    } catch (err) {
+      console.error("[handleError] reporting failed:", err);
+    }
+    return respondTo(options, input);
+  };
+}
+
+/**
+ * `handleError` for `hooks.server.ts`. Awaits the send, because a Worker stops when the
+ * response ends and would drop a fire-and-forget request. The `cause` chain rides along
+ * in the event (see `buildErrorRequest`).
+ */
+export function createHandleServerError<R = undefined>(options: ServerErrorOptions<R>) {
+  return async (input: CaughtInput): Promise<R | undefined> => {
+    try {
+      if (shouldReport(input)) {
+        // WHY the error itself, not its stack: Node and workerd print `cause` for an Error.
+        if (options.log !== false) console.error("[handleError]", toError(input.error));
+        await report(options, input);
+      }
+    } catch (err) {
+      console.error("[handleError] reporting failed:", err);
+    }
+    return respondTo(options, input);
+  };
+}

package/src/format.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vite-plus/test";
+import { formatDate, formatCurrency, formatAmount, formatRelativeTime } from "#src/format.ts";
+
+describe("formatDate", () => {
+  it("formats a Date object to readable string", () => {
+    const date = new Date("2025-01-21T00:00:00.000Z");
+    // Use a fixed UTC date because locale output varies; just check it's not '-'
+    const result = formatDate(date, "en-US");
+    expect(result).not.toBe("-");
+    expect(result).toMatch(/2025/);
+  });
+
+  it("returns '-' for null", () => {
+    expect(formatDate(null)).toBe("-");
+  });
+
+  it("returns '-' for undefined", () => {
+    expect(formatDate(undefined)).toBe("-");
+  });
+
+  it("returns '-' for an invalid date string", () => {
+    expect(formatDate("not-a-date")).toBe("-");
+  });
+
+  it("formats a numeric string (ClickUp timestamp)", () => {
+    const ts = new Date("2024-06-01").getTime();
+    const result = formatDate(String(ts), "en-US");
+    expect(result).toMatch(/2024/);
+    expect(result).not.toBe("-");
+  });
+
+  it("formats a numeric timestamp", () => {
+    const ts = new Date("2024-03-15").getTime();
+    const result = formatDate(ts, "en-US");
+    expect(result).toMatch(/2024/);
+  });
+
+  it("formats a date string", () => {
+    const result = formatDate("2024-07-04", "en-US");
+    expect(result).toMatch(/2024/);
+    expect(result).not.toBe("-");
+  });
+});
+
+describe("formatCurrency", () => {
+  it("returns '-' for null", () => {
+    expect(formatCurrency(null)).toBe("-");
+  });
+
+  it("returns '-' for undefined", () => {
+    expect(formatCurrency(undefined)).toBe("-");
+  });
+
+  it("returns '-' for zero", () => {
+    expect(formatCurrency(0)).toBe("-");
+  });
+
+  it("formats USD by default", () => {
+    const result = formatCurrency(5000);
+    expect(result).toContain("5");
+    expect(result).toMatch(/[$5,]/);
+  });
+
+  it("formats EUR with fr-FR locale when no locale provided", () => {
+    const result = formatCurrency(1000, "EUR");
+    expect(result).toContain("1");
+    expect(result).toMatch(/€|EUR/);
+  });
+
+  it("respects explicit locale override", () => {
+    const result = formatCurrency(1000, "USD", "en-US");
+    expect(result).toContain("1");
+  });
+});
+
+describe("formatAmount", () => {
+  it("converts cents to dollars and formats", () => {
+    const result = formatAmount(1500, "USD", "en-US");
+    expect(result).toContain("15");
+    expect(result).toContain(".");
+  });
+
+  it("shows two decimal places", () => {
+    const result = formatAmount(100, "USD", "en-US");
+    expect(result).toMatch(/1\.00/);
+  });
+
+  it("handles 0 cents", () => {
+    const result = formatAmount(0, "USD", "en-US");
+    expect(result).toMatch(/0\.00/);
+  });
+});
+
+describe("formatRelativeTime", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns '-' for null", () => {
+    expect(formatRelativeTime(null)).toBe("-");
+  });
+
+  it("returns '-' for undefined", () => {
+    expect(formatRelativeTime(undefined)).toBe("-");
+  });
+
+  it("returns '-' for an invalid date string", () => {
+    expect(formatRelativeTime("not-a-date")).toBe("-");
+  });
+
+  it("returns 'Today' for today's date", () => {
+    const now = new Date("2024-06-01T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const today = new Date("2024-06-01T08:00:00.000Z");
+    expect(formatRelativeTime(today.toISOString())).toBe("Today");
+  });
+
+  it("returns 'Yesterday' for a date 1 day ago", () => {
+    const now = new Date("2024-06-02T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const yesterday = new Date("2024-06-01T12:00:00.000Z");
+    expect(formatRelativeTime(yesterday.toISOString())).toBe("Yesterday");
+  });
+
+  it("returns 'N days ago' for 2-6 days ago", () => {
+    const now = new Date("2024-06-10T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const fiveDaysAgo = new Date("2024-06-05T12:00:00.000Z");
+    expect(formatRelativeTime(fiveDaysAgo.toISOString())).toBe("5 days ago");
+  });
+
+  it("returns 'N weeks ago' for 7-29 days ago", () => {
+    const now = new Date("2024-06-15T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const twoWeeksAgo = new Date("2024-06-01T12:00:00.000Z");
+    expect(formatRelativeTime(twoWeeksAgo.toISOString())).toBe("2 weeks ago");
+  });
+
+  it("uses singular labels when the count is exactly 1", () => {
+    const now = new Date("2024-06-15T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const oneWeekAgo = new Date("2024-06-07T12:00:00.000Z");
+    expect(formatRelativeTime(oneWeekAgo.toISOString())).toBe("1 week ago");
+
+    const oneMonthAgo = new Date("2024-05-10T12:00:00.000Z");
+    expect(formatRelativeTime(oneMonthAgo.toISOString())).toBe("1 month ago");
+
+    const oneYearAgo = new Date("2023-06-01T12:00:00.000Z");
+    expect(formatRelativeTime(oneYearAgo.toISOString())).toBe("1 year ago");
+  });
+
+  it("falls back to plural labels when no singular label is provided", () => {
+    const now = new Date("2024-06-15T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const oneWeekAgo = new Date("2024-06-07T12:00:00.000Z");
+    const labels = {
+      today: "Today",
+      yesterday: "Yesterday",
+      daysAgo: "{n} days ago",
+      weeksAgo: "{n} weeks ago",
+      monthsAgo: "{n} months ago",
+      yearsAgo: "{n} years ago",
+    };
+    expect(formatRelativeTime(oneWeekAgo.toISOString(), labels)).toBe("1 weeks ago");
+  });
+
+  it("returns 'N months ago' for 30-364 days ago", () => {
+    const now = new Date("2024-09-01T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const threeMonthsAgo = new Date("2024-06-01T12:00:00.000Z");
+    expect(formatRelativeTime(threeMonthsAgo.toISOString())).toBe("3 months ago");
+  });
+
+  it("returns 'N years ago' for 365+ days ago", () => {
+    const now = new Date("2026-01-01T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const twoYearsAgo = new Date("2024-01-01T12:00:00.000Z");
+    expect(formatRelativeTime(twoYearsAgo.toISOString())).toBe("2 years ago");
+  });
+
+  it("accepts a numeric timestamp", () => {
+    const now = new Date("2024-06-01T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const todayMs = new Date("2024-06-01T08:00:00.000Z").getTime();
+    expect(formatRelativeTime(todayMs)).toBe("Today");
+  });
+
+  it("accepts a numeric-string timestamp", () => {
+    const now = new Date("2024-06-01T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const todayMs = String(new Date("2024-06-01T08:00:00.000Z").getTime());
+    expect(formatRelativeTime(todayMs)).toBe("Today");
+  });
+
+  it("uses custom labels", () => {
+    const now = new Date("2024-06-10T12:00:00.000Z");
+    vi.setSystemTime(now);
+
+    const fiveDaysAgo = new Date("2024-06-05T12:00:00.000Z");
+    const labels = {
+      today: "Aujourd'hui",
+      yesterday: "Hier",
+      daysAgo: "il y a {n} jours",
+      weeksAgo: "il y a {n} semaines",
+      monthsAgo: "il y a {n} mois",
+      yearsAgo: "il y a {n} ans",
+    };
+
+    expect(formatRelativeTime(fiveDaysAgo.toISOString(), labels)).toBe("il y a 5 jours");
+  });
+});

package/src/format.ts

@@ -0,0 +1,103 @@
+/** Format date to readable string (e.g., "Jan 21, 2025" or "21 janv. 2025") */
+export function formatDate(
+  date: Date | string | number | null | undefined,
+  locale = "en-US",
+): string {
+  if (!date) return "-";
+
+  // Convert string numbers to actual numbers (e.g. ClickUp timestamps)
+  const dateValue = typeof date === "string" && /^\d+$/.test(date) ? parseInt(date, 10) : date;
+
+  const parsed = new Date(dateValue);
+  if (Number.isNaN(parsed.getTime())) return "-";
+
+  return parsed.toLocaleDateString(locale, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+}
+
+/** Format currency value (e.g., "$5,000" or "5 000 €") */
+export function formatCurrency(
+  value: number | null | undefined,
+  currency: string = "USD",
+  locale?: string,
+): string {
+  if (!value) return "-";
+
+  const resolvedLocale = locale ?? (currency.toUpperCase() === "EUR" ? "fr-FR" : "en-US");
+
+  return new Intl.NumberFormat(resolvedLocale, {
+    style: "currency",
+    currency: currency.toUpperCase(),
+    minimumFractionDigits: 0,
+  }).format(value);
+}
+
+/** Format amount from cents (e.g., 1500 cents → "$15.00") */
+export function formatAmount(cents: number, currency: string, locale = "en-US"): string {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currency.toUpperCase(),
+    minimumFractionDigits: 2,
+  }).format(cents / 100);
+}
+
+export type RelativeTimeLabels = {
+  today: string;
+  yesterday: string;
+  daysAgo: string;
+  weeksAgo: string;
+  monthsAgo: string;
+  yearsAgo: string;
+  /** Singular forms used when the count is exactly 1 (e.g., "1 week ago") */
+  weekAgo?: string;
+  monthAgo?: string;
+  yearAgo?: string;
+};
+
+const DEFAULT_LABELS: RelativeTimeLabels = {
+  today: "Today",
+  yesterday: "Yesterday",
+  daysAgo: "{n} days ago",
+  weeksAgo: "{n} weeks ago",
+  monthsAgo: "{n} months ago",
+  yearsAgo: "{n} years ago",
+  weekAgo: "1 week ago",
+  monthAgo: "1 month ago",
+  yearAgo: "1 year ago",
+};
+
+/** Format relative time (e.g., "2 days ago") with customizable labels for i18n */
+export function formatRelativeTime(
+  date: string | number | null | undefined,
+  labels: RelativeTimeLabels = DEFAULT_LABELS,
+): string {
+  if (!date) return "-";
+
+  const dateValue = typeof date === "string" && /^\d+$/.test(date) ? parseInt(date, 10) : date;
+
+  const parsed = new Date(dateValue);
+  if (Number.isNaN(parsed.getTime())) return "-";
+
+  const diffMs = Date.now() - parsed.getTime();
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffDays === 0) return labels.today;
+  if (diffDays === 1) return labels.yesterday;
+  if (diffDays < 7) return labels.daysAgo.replace("{n}", String(diffDays));
+  if (diffDays < 30) {
+    const weeks = Math.floor(diffDays / 7);
+    if (weeks === 1 && labels.weekAgo) return labels.weekAgo;
+    return labels.weeksAgo.replace("{n}", String(weeks));
+  }
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    if (months === 1 && labels.monthAgo) return labels.monthAgo;
+    return labels.monthsAgo.replace("{n}", String(months));
+  }
+  const years = Math.floor(diffDays / 365);
+  if (years === 1 && labels.yearAgo) return labels.yearAgo;
+  return labels.yearsAgo.replace("{n}", String(years));
+}

package/src/grab.d.ts

@@ -0,0 +1,2 @@
+/** Side-effect module: importing it turns on Alt+Click grab. Dev only. */
+export {};

package/src/grab.js

@@ -0,0 +1,112 @@
+/**
+ * Alt+Click any element in a Svelte 5 dev build to copy its HTML and component stack for a coding agent.
+ */
+
+/*
+ * Usage in +layout.svelte: if (dev) import("@heyramzi/utils/grab");
+ */
+
+/*
+ * Plain JS with no imports, so a page can also inline this file as a <script type="module">.
+ */
+
+const MAX_HTML = 400;
+
+/** @param {Element} el */
+function sourceOf(el) {
+  /** @type {Element | null} */
+  let node = el;
+  while (node && !(/** @type {any} */ (node).__svelte_meta)) node = node.parentElement;
+  return node ? /** @type {any} */ (node).__svelte_meta : null;
+}
+
+/** @param {{ file: string, line: number, column: number }} at */
+function where(at) {
+  return `${at.file}:${at.line}:${at.column}`;
+}
+
+/** @param {Element} el */
+function describe(el) {
+  // Svelte's hydration markers are <!----> comments, noise to an agent.
+  const full = el.outerHTML.replace(/<!--[^]*?-->/g, "");
+  const html = full.length > MAX_HTML ? `${full.slice(0, MAX_HTML)}…` : full;
+  const meta = sourceOf(el);
+  if (!meta) return html;
+
+  const lines = [html, `  at ${where(meta.loc)}`];
+  for (let entry = meta.parent; entry; entry = entry.parent) {
+    if (entry.type === "component") lines.push(`  in <${entry.componentTag}> at ${where(entry)}`);
+  }
+  return lines.join("\n");
+}
+
+/** @param {Element} el */
+function label(el) {
+  const meta = sourceOf(el);
+  let entry = meta?.parent;
+  while (entry && entry.type !== "component") entry = entry.parent;
+  const name = entry ? `<${entry.componentTag}>` : el.tagName.toLowerCase();
+  return meta ? `${name}  ${meta.loc.file.split("/").pop()}:${meta.loc.line}` : name;
+}
+
+function start() {
+  const box = document.createElement("div");
+  const tag = document.createElement("div");
+  box.style.cssText =
+    "position:fixed;pointer-events:none;z-index:2147483647;border:2px solid #7c3aed;background:rgb(124 58 237 / 0.08);border-radius:3px;display:none";
+  tag.style.cssText =
+    "position:absolute;left:-2px;bottom:100%;margin-bottom:4px;padding:2px 6px;font:12px/1.4 ui-monospace,monospace;color:#fff;background:#7c3aed;border-radius:3px;white-space:nowrap";
+  box.append(tag);
+  document.body.append(box);
+
+  /** @type {Element | null} */
+  let target = null;
+
+  /** @param {Element | null} el */
+  function show(el) {
+    target = el;
+    if (!el) {
+      box.style.display = "none";
+      return;
+    }
+    const r = el.getBoundingClientRect();
+    Object.assign(box.style, {
+      display: "block",
+      left: `${r.left}px`,
+      top: `${r.top}px`,
+      width: `${r.width}px`,
+      height: `${r.height}px`,
+    });
+    tag.textContent = label(el);
+  }
+
+  /** @param {MouseEvent} e */
+  function onMove(e) {
+    show(e.altKey ? document.elementFromPoint(e.clientX, e.clientY) : null);
+  }
+
+  /** @param {MouseEvent} e */
+  function onClick(e) {
+    if (!e.altKey || !target) return;
+    // Option+click on a link downloads it in Chrome, so the click is swallowed here.
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    if (e.type !== "click") return;
+    navigator.clipboard.writeText(describe(target)).then(() => {
+      tag.textContent = "Copied";
+    });
+  }
+
+  addEventListener("mousemove", onMove, true);
+  addEventListener("mousedown", onClick, true);
+  addEventListener("click", onClick, true);
+  addEventListener("keyup", (e) => e.key === "Alt" && show(null), true);
+  addEventListener("blur", () => show(null));
+}
+
+const w = /** @type {any} */ (globalThis);
+if (typeof document !== "undefined" && !w.__heyramziGrab) {
+  w.__heyramziGrab = true;
+  if (document.body) start();
+  else addEventListener("DOMContentLoaded", start);
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+export {
+  cn,
+  type WithElementRef,
+  type WithoutChild,
+  type WithoutChildren,
+  type WithoutChildrenOrChild,
+} from "#src/cn.js";
+
+export {
+  formatDate,
+  formatCurrency,
+  formatAmount,
+  formatRelativeTime,
+  type RelativeTimeLabels,
+} from "#src/format.js";
+
+export {
+  slugify,
+  generateSlug,
+  buildSearchParams,
+  parseJSON,
+  parseCommaSeparatedList,
+  matchesQuery,
+} from "#src/string.js";
+
+export { fetchApi } from "#src/error.js";
+
+export { isCacheExpired } from "#src/cache.js";
+
+export { Ok, Err, tryCatch, tryCatchAsync } from "#src/result.js";
+export type { Result } from "#src/result.js";
+
+export type { Logger, LogLevel, LogEntry } from "#src/logger-types.js";
+export { setLogger, log } from "#src/logger.js";
+
+export { debounce, throttle, sleep } from "#src/timing.js";
+export { clamp } from "#src/math.js";
+export { groupBy } from "#src/collection.js";

package/src/logger-types.ts

@@ -0,0 +1,14 @@
+export type LogLevel = "error" | "warn" | "info" | "debug";
+
+export type LogEntry = {
+  level: LogLevel;
+  message: string;
+  project?: string;
+  stack?: string;
+  url?: string;
+  [key: string]: unknown;
+};
+
+export type Logger = {
+  log(entry: LogEntry): void | Promise<void>;
+};