@everscribe/components-core 0.1.0

package/dist/index.js

@@ -0,0 +1,634 @@
+// src/api.ts
+var EmbedError = class extends Error {
+  constructor(info) {
+    super(info.message ?? info.kind);
+    this.name = "EmbedError";
+    this.kind = info.kind;
+    this.status = info.status;
+    this.retryAfterMs = info.retryAfterMs;
+  }
+};
+async function listEvents(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events"));
+  applyListParams(url, opts.params);
+  return request(url, opts);
+}
+function applyListParams(url, p) {
+  if (!p) return;
+  if (p.limit !== void 0) url.searchParams.set("limit", String(p.limit));
+  if (p.cursor) url.searchParams.set("cursor", p.cursor);
+  if (p.since) url.searchParams.set("since", p.since);
+  if (p.before) url.searchParams.set("before", p.before);
+  if (p.action) url.searchParams.set("action", p.action);
+  if (p.actor) url.searchParams.set("actor", p.actor);
+  if (p.actorType) url.searchParams.set("actor_type", p.actorType);
+  if (p.tenantId) url.searchParams.set("tenant_id", p.tenantId);
+  if (p.targetType) url.searchParams.set("target_type", p.targetType);
+  if (p.targetId) url.searchParams.set("target_id", p.targetId);
+  if (p.resultStatus) url.searchParams.set("result_status", p.resultStatus);
+  if (p.originIP) url.searchParams.set("origin_ip", p.originIP);
+  if (p.q) url.searchParams.set("q", p.q);
+}
+async function getEvent(opts) {
+  const url = new URL(joinUrl(opts.apiBase, `events/${encodeURIComponent(opts.id)}`));
+  return request(url, opts);
+}
+async function listDistinctActions(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/actions"));
+  return request(url, opts);
+}
+async function listDistinctActorTypes(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/actor-types"));
+  return request(url, opts);
+}
+async function listDistinctTargetTypes(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/target-types"));
+  return request(url, opts);
+}
+async function listDistinctTenants(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/tenants"));
+  return request(url, opts);
+}
+async function listDistinctResultStatuses(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/result-statuses"));
+  return request(url, opts);
+}
+async function listMetadataKeys(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/metadata-keys"));
+  return request(url, opts);
+}
+async function listChangeFields(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/change-fields"));
+  return request(url, opts);
+}
+async function generateNLPFilters(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/nlp"));
+  const body = { q: opts.query };
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${opts.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") throw err;
+    throw new EmbedError({ kind: "network", cause: err, message: "network error" });
+  }
+  if (res.ok) return await res.json();
+  if (res.status === 403) {
+    const message = (await res.text()).trim() || "nlp_not_allowed";
+    throw new EmbedError({ kind: "bad_request", status: 403, message });
+  }
+  throw await mapErrorResponse(res);
+}
+async function exportEvents(opts) {
+  const url = new URL(joinUrl(opts.apiBase, "events/export"));
+  const { format, ...rest } = opts.params;
+  url.searchParams.set("format", format);
+  applyListParams(url, rest);
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Authorization: `Bearer ${opts.token}` },
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") throw err;
+    throw new EmbedError({ kind: "network", cause: err, message: "network error" });
+  }
+  if (!res.ok) throw await mapErrorResponse(res);
+  const blob = await res.blob();
+  const filename = parseFilenameFromContentDisposition(res.headers.get("Content-Disposition")) ?? `events.${format}`;
+  return { blob, filename };
+}
+function parseFilenameFromContentDisposition(value) {
+  if (!value) return void 0;
+  const quoted = /filename="([^"]+)"/.exec(value);
+  if (quoted?.[1]) return quoted[1];
+  const unquoted = /filename=([^;]+)/.exec(value);
+  if (unquoted?.[1]) return unquoted[1].trim();
+  return void 0;
+}
+async function request(url, opts) {
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Authorization: `Bearer ${opts.token}` },
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") throw err;
+    throw new EmbedError({ kind: "network", cause: err, message: "network error" });
+  }
+  if (res.ok) return await res.json();
+  throw await mapErrorResponse(res);
+}
+async function mapErrorResponse(res) {
+  switch (res.status) {
+    case 401:
+      return new EmbedError({ kind: "unauthorized", status: 401 });
+    case 404:
+      return new EmbedError({ kind: "not_found", status: 404 });
+    case 429: {
+      const retryAfterMs = parseRetryAfter(res.headers.get("Retry-After"));
+      return new EmbedError({ kind: "rate_limited", status: 429, retryAfterMs });
+    }
+    case 400: {
+      const message = (await res.text()).trim() || "bad request";
+      return new EmbedError({ kind: "bad_request", status: 400, message });
+    }
+    default:
+      return new EmbedError({
+        kind: "server",
+        status: res.status,
+        message: `unexpected status ${res.status}`
+      });
+  }
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const t = Date.parse(value);
+  if (!Number.isNaN(t)) return Math.max(0, t - Date.now());
+  return void 0;
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function fetchTokenViaOpts(opts) {
+  try {
+    if (opts.onTokenExpired) return await opts.onTokenExpired();
+    if (opts.tokenEndpoint) {
+      const res = await fetch(opts.tokenEndpoint, {
+        method: "POST",
+        credentials: "include"
+      });
+      if (!res.ok) return null;
+      const body = await res.json();
+      return body.token ?? null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/jwt.ts
+function decodeJwtPayload(token) {
+  const parts = token.trim().split(".");
+  if (parts.length !== 3) {
+    throw new Error("malformed token: expected three dot-separated segments");
+  }
+  const b64url = parts[1];
+  if (!b64url) throw new Error("malformed token: empty payload segment");
+  const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = (4 - b64.length % 4) % 4;
+  const padded = b64 + "=".repeat(pad);
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  const json = new TextDecoder().decode(bytes);
+  return JSON.parse(json);
+}
+
+// src/claims.ts
+function parseClaims(token) {
+  if (!token) return null;
+  try {
+    return decodeJwtPayload(token);
+  } catch {
+    return null;
+  }
+}
+
+// src/diff.ts
+function renderDiff(change) {
+  if (change == null || typeof change !== "object") return { lines: [] };
+  const c = change;
+  if (c.before === void 0 && c.after === void 0) return { lines: [] };
+  const beforeStr = prettyJSON(c.before);
+  const afterStr = prettyJSON(c.after);
+  return { lines: lineDiff(splitLines(beforeStr), splitLines(afterStr)) };
+}
+function hasParseableDiff(change) {
+  if (change == null || typeof change !== "object") return false;
+  const c = change;
+  return c.before !== void 0 || c.after !== void 0;
+}
+function prettyJSON(v) {
+  if (v === void 0 || v === null) return "null";
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}
+function splitLines(s) {
+  if (s === "") return [];
+  return s.split("\n");
+}
+function lineDiff(before, after) {
+  const n = before.length;
+  const m = after.length;
+  if (n === 0 && m === 0) return [];
+  const dp = Array.from(
+    { length: n + 1 },
+    () => new Array(m + 1).fill(0)
+  );
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    const row = dp[i2];
+    const next = dp[i2 + 1];
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      if (before[i2] === after[j2]) {
+        row[j2] = next[j2 + 1] + 1;
+      } else if (next[j2] >= row[j2 + 1]) {
+        row[j2] = next[j2];
+      } else {
+        row[j2] = row[j2 + 1];
+      }
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (before[i] === after[j]) {
+      out.push({
+        before: before[i],
+        after: after[j],
+        beforeKind: "same",
+        afterKind: "same"
+      });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      out.push({ before: before[i], after: "", beforeKind: "removed", afterKind: "" });
+      i++;
+    } else {
+      out.push({ before: "", after: after[j], beforeKind: "", afterKind: "added" });
+      j++;
+    }
+  }
+  while (i < n) {
+    out.push({ before: before[i], after: "", beforeKind: "removed", afterKind: "" });
+    i++;
+  }
+  while (j < m) {
+    out.push({ before: "", after: after[j], beforeKind: "", afterKind: "added" });
+    j++;
+  }
+  return out;
+}
+
+// src/columns.ts
+var COLUMN_LABELS = {
+  id: "ID",
+  tenant_id: "Tenant",
+  occurred_at: "Time",
+  actor: "Actor",
+  action: "Action",
+  target: "Target",
+  metadata: "Metadata",
+  origin: "Origin",
+  result: "Result",
+  change: "Change",
+  idempotency_key: "Idempotency key"
+};
+var ALL_COLUMNS = [
+  "occurred_at",
+  "action",
+  "actor",
+  "target",
+  "tenant_id",
+  "result"
+];
+
+// src/time.ts
+var TIMESTAMP_FMT = new Intl.DateTimeFormat(void 0, {
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  hour: "numeric",
+  minute: "2-digit",
+  second: "2-digit"
+});
+function formatAbsolute(rfc3339) {
+  const d = new Date(rfc3339);
+  if (Number.isNaN(d.getTime())) return rfc3339;
+  return TIMESTAMP_FMT.format(d);
+}
+function formatRelative(rfc3339, now) {
+  const d = new Date(rfc3339);
+  if (Number.isNaN(d.getTime())) return "";
+  const ms = now - d.getTime();
+  if (ms < 0) return "just now";
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 30) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months}mo ago`;
+  const years = Math.floor(days / 365);
+  return `${years}y ago`;
+}
+function formatTimeCell(rfc3339, now) {
+  const absolute = formatAbsolute(rfc3339);
+  const relative = formatRelative(rfc3339, now);
+  if (!relative) return absolute;
+  return `${absolute} (${relative})`;
+}
+var RELATIVE_TIME_TICK_MS = 3e4;
+
+// src/eventsStore.ts
+var MIN_POLL_INTERVAL_MS = 1e3;
+var INITIAL_STATE = {
+  events: [],
+  nextCursor: null,
+  status: "loading",
+  error: null
+};
+function createEventsStore(config) {
+  let state = INITIAL_STATE;
+  const listeners = /* @__PURE__ */ new Set();
+  let token = config.token;
+  let disposed = false;
+  let activeAbort = null;
+  let pollTimer = null;
+  let visibilityHandler = null;
+  const setState = (next) => {
+    state = next;
+    for (const l of listeners) l();
+  };
+  const fetchPage = async (kind, signal) => {
+    if (!token) return;
+    const params = { limit: config.pageSize };
+    if (config.since) params.since = config.since;
+    if (config.before) params.before = config.before;
+    if (config.action) params.action = config.action;
+    if (config.actor) params.actor = config.actor;
+    if (config.actorType) params.actorType = config.actorType;
+    if (config.tenantId) params.tenantId = config.tenantId;
+    if (config.targetType) params.targetType = config.targetType;
+    if (config.targetId) params.targetId = config.targetId;
+    if (config.resultStatus) params.resultStatus = config.resultStatus;
+    if (config.originIP) params.originIP = config.originIP;
+    if (config.q) params.q = config.q;
+    if (kind === "poll") {
+      const newest = state.events[0]?.occurred_at;
+      if (newest) params.since = newest;
+    } else if (kind === "more") {
+      if (!state.nextCursor) return;
+      params.cursor = state.nextCursor;
+    }
+    const doFetch = async (t, allowRefresh) => {
+      try {
+        return await listEvents({ apiBase: config.apiBase, token: t, signal, params });
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") throw err;
+        if (allowRefresh && err instanceof EmbedError && err.kind === "unauthorized") {
+          const newTok = await fetchTokenViaOpts({
+            tokenEndpoint: config.tokenEndpoint,
+            onTokenExpired: config.onTokenExpired
+          });
+          if (!newTok) throw err;
+          token = newTok;
+          return doFetch(newTok, false);
+        }
+        throw err;
+      }
+    };
+    let response;
+    try {
+      response = await doFetch(token, true);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") return;
+      const e = err instanceof EmbedError ? err : new EmbedError({ kind: "network", cause: err, message: "network error" });
+      setState({
+        ...state,
+        status: e.kind === "unauthorized" ? "expired" : "error",
+        error: e
+      });
+      config.onError?.(e);
+      return;
+    }
+    if (kind === "initial") {
+      setState({
+        events: response.events,
+        nextCursor: response.next_cursor ?? null,
+        status: "ok",
+        error: null
+      });
+    } else if (kind === "poll") {
+      const events = response.events.length > 0 ? mergeNewer(response.events, state.events) : state.events;
+      setState({ ...state, events, status: "ok", error: null });
+    } else {
+      setState({
+        events: mergeOlder(state.events, response.events),
+        nextCursor: response.next_cursor ?? null,
+        status: "ok",
+        error: null
+      });
+    }
+  };
+  const startPolling = () => {
+    if (config.pollInterval <= 0) return;
+    if (config.before) return;
+    let interval = config.pollInterval;
+    if (interval < MIN_POLL_INTERVAL_MS) {
+      console.warn(
+        `[everscribe] pollInterval=${interval}ms is below minimum ${MIN_POLL_INTERVAL_MS}ms; clamping to ${MIN_POLL_INTERVAL_MS}ms`
+      );
+      interval = MIN_POLL_INTERVAL_MS;
+    }
+    const schedule = () => {
+      if (disposed) return;
+      pollTimer = setTimeout(tick, interval);
+    };
+    const tick = async () => {
+      if (disposed) return;
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+        schedule();
+        return;
+      }
+      const ctrl = new AbortController();
+      activeAbort = ctrl;
+      try {
+        await fetchPage("poll", ctrl.signal);
+      } finally {
+        if (activeAbort === ctrl) activeAbort = null;
+        schedule();
+      }
+    };
+    schedule();
+    if (typeof document !== "undefined") {
+      visibilityHandler = () => {
+        if (disposed) return;
+        if (document.visibilityState === "visible") {
+          if (pollTimer) {
+            clearTimeout(pollTimer);
+            pollTimer = null;
+          }
+          void tick();
+        }
+      };
+      document.addEventListener("visibilitychange", visibilityHandler);
+    }
+  };
+  const stopPolling = () => {
+    if (pollTimer) {
+      clearTimeout(pollTimer);
+      pollTimer = null;
+    }
+    if (visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", visibilityHandler);
+      visibilityHandler = null;
+    }
+  };
+  const runInitialFetch = () => {
+    if (!token) return;
+    const ctrl = new AbortController();
+    activeAbort = ctrl;
+    void fetchPage("initial", ctrl.signal).finally(() => {
+      if (activeAbort === ctrl) activeAbort = null;
+    });
+  };
+  runInitialFetch();
+  startPolling();
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    loadMore() {
+      if (disposed) return;
+      if (!state.nextCursor) return;
+      const ctrl = new AbortController();
+      void fetchPage("more", ctrl.signal);
+    },
+    refresh() {
+      if (disposed) return;
+      stopPolling();
+      if (activeAbort) activeAbort.abort();
+      setState(INITIAL_STATE);
+      runInitialFetch();
+      startPolling();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stopPolling();
+      if (activeAbort) activeAbort.abort();
+      listeners.clear();
+    }
+  };
+}
+function mergeNewer(incoming, existing) {
+  const seen = new Set(existing.map((e) => e.id));
+  const fresh = incoming.filter((e) => !seen.has(e.id));
+  if (fresh.length === 0) return existing;
+  return [...fresh, ...existing];
+}
+function mergeOlder(existing, incoming) {
+  const seen = new Set(existing.map((e) => e.id));
+  const fresh = incoming.filter((e) => !seen.has(e.id));
+  return [...existing, ...fresh];
+}
+
+// src/distinctValuesStore.ts
+var EMPTY_DISTINCT_VALUES = {
+  actions: [],
+  actorTypes: [],
+  targetTypes: [],
+  tenants: [],
+  resultStatuses: [],
+  metadataKeys: [],
+  changeFields: []
+};
+function createDistinctValuesStore(config) {
+  let state = EMPTY_DISTINCT_VALUES;
+  const listeners = /* @__PURE__ */ new Set();
+  const ctrl = new AbortController();
+  let disposed = false;
+  const setState = (next) => {
+    state = next;
+    for (const l of listeners) l();
+  };
+  const fetchOnce = async (token) => {
+    const base = { apiBase: config.apiBase, token, signal: ctrl.signal };
+    const [actions, actorTypes, targetTypes, tenants, statuses, mdk, cf] = await Promise.all([
+      listDistinctActions(base).catch(() => ({ actions: [] })),
+      listDistinctActorTypes(base).catch(() => ({ actor_types: [] })),
+      listDistinctTargetTypes(base).catch(() => ({ target_types: [] })),
+      // The server returns an empty list when the token is tenant-
+      // scoped, so the UI hides the tenant dropdown for those tokens
+      // automatically.
+      listDistinctTenants(base).catch(() => ({ tenants: [] })),
+      listDistinctResultStatuses(base).catch(() => ({ statuses: [] })),
+      listMetadataKeys(base).catch(() => ({ keys: [] })),
+      listChangeFields(base).catch(() => ({ fields: [] }))
+    ]);
+    if (disposed) return;
+    setState({
+      actions: actions.actions ?? [],
+      actorTypes: actorTypes.actor_types ?? [],
+      targetTypes: targetTypes.target_types ?? [],
+      tenants: tenants.tenants ?? [],
+      resultStatuses: statuses.statuses ?? [],
+      metadataKeys: mdk.keys ?? [],
+      changeFields: cf.fields ?? []
+    });
+  };
+  if (config.token) {
+    void (async () => {
+      try {
+        await fetchOnce(config.token);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (err instanceof EmbedError && err.kind === "unauthorized") {
+          const refreshed = await fetchTokenViaOpts({
+            tokenEndpoint: config.tokenEndpoint,
+            onTokenExpired: config.onTokenExpired
+          });
+          if (refreshed && !disposed) {
+            try {
+              await fetchOnce(refreshed);
+            } catch {
+            }
+          }
+        }
+      }
+    })();
+  }
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      ctrl.abort();
+      listeners.clear();
+    }
+  };
+}
+
+export { ALL_COLUMNS, COLUMN_LABELS, EMPTY_DISTINCT_VALUES, EmbedError, RELATIVE_TIME_TICK_MS, createDistinctValuesStore, createEventsStore, decodeJwtPayload, exportEvents, fetchTokenViaOpts, formatAbsolute, formatRelative, formatTimeCell, generateNLPFilters, getEvent, hasParseableDiff, listChangeFields, listDistinctActions, listDistinctActorTypes, listDistinctResultStatuses, listDistinctTargetTypes, listDistinctTenants, listEvents, listMetadataKeys, parseClaims, renderDiff };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map