@pihanga2/shadcn 0.2.21 → 0.2.23

package/cards/swimlane/swimlane.model.js

@@ -0,0 +1,203 @@
+import { onSwimlaneEventsReceived as e, onSwimlaneRowsCleared as t } from "./swimlane.types.js";
+//#region src/cards/swimlane/swimlane.model.ts
+function n(e = {}) {
+	return {
+		laneOrder: [],
+		laneLabels: {},
+		current: {},
+		rows: [],
+		pending: [],
+		spans: {},
+		seq: 0,
+		maxRows: e.maxRows ?? 2e3
+	};
+}
+function r(e) {
+	let t = {};
+	for (let n of Object.keys(e)) t[n] = {
+		state: e[n].state,
+		acts: [...e[n].acts]
+	};
+	return t;
+}
+function i(e, t) {
+	switch (t.type) {
+		case "state": return [t.lane];
+		case "call": return t.from === t.to ? [t.from] : [t.from, t.to];
+		case "expect": return t.from === t.to ? [t.from] : [t.from, t.to];
+		case "reply":
+		case "done": {
+			let n = e.spans[t.id];
+			return n ? [n.to, n.from] : [];
+		}
+		default: return [];
+	}
+}
+function a(e, t, n = Date.now()) {
+	for (let r of t) {
+		let t = r.ts ?? n;
+		for (let n of i(e, r)) e.current[n] || o(e, {
+			type: "lane",
+			lane: n
+		}, t);
+		o(e, r, t);
+	}
+	s(e);
+}
+function o(e, t, n) {
+	let i = e.current;
+	if (t.type === "expect") {
+		e.pending.push({
+			id: t.id,
+			type: "expect",
+			from: t.from,
+			to: t.to,
+			label: t.label,
+			since: n,
+			timeoutMs: t.timeoutMs
+		});
+		return;
+	}
+	let a = r(i), o;
+	switch (t.type) {
+		case "lane":
+			if (t.label && (e.laneLabels[t.lane] = t.label), i[t.lane]) return;
+			i[t.lane] = {
+				state: "created",
+				acts: []
+			}, e.laneOrder.push(t.lane);
+			break;
+		case "state":
+			i[t.lane].state = t.state;
+			break;
+		case "call": {
+			let r = i[t.from]?.acts ?? [], a = t.parentId ?? r[r.length - 1];
+			e.spans[t.id] = {
+				id: t.id,
+				kind: t.kind,
+				from: t.from,
+				to: t.to,
+				label: t.label,
+				start: n,
+				end: t.kind === "event" ? n : void 0,
+				status: t.kind === "event" ? "done" : "open"
+			}, a && a !== t.id && (e.spans[t.id].parent = a), t.kind !== "event" && i[t.to].acts.push(t.id);
+			break;
+		}
+		case "reply":
+		case "done": {
+			let r = e.spans[t.id];
+			if (!r) return;
+			r.end = n, r.status = t.type === "done" ? "done" : t.ok ? "ok" : "error", t.type === "reply" && (r.result = t.label);
+			let a = i[r.to];
+			if (a) {
+				let e = a.acts.indexOf(t.id);
+				e >= 0 && a.acts.splice(e, 1);
+			}
+			o = {
+				from: r.from,
+				to: r.to,
+				label: r.label
+			};
+			break;
+		}
+	}
+	let s, c = t.type === "reply" ? t.id : t.fulfils;
+	if (c) {
+		let t = e.pending.findIndex((e) => e.id === c);
+		t >= 0 && (e.pending.splice(t, 1), s = c);
+	}
+	t.type === "call" && t.kind === "sync" && e.pending.push({
+		id: t.id,
+		type: "reply",
+		from: t.to,
+		to: t.from,
+		label: `reply: ${t.label}`,
+		since: n,
+		timeoutMs: t.timeoutMs
+	});
+	let l = {
+		id: ++e.seq,
+		event: {
+			...t,
+			ts: n
+		},
+		pre: a,
+		post: r(i)
+	};
+	s && (l.fulfilled = s), o && (l.route = o), e.rows.push(l);
+}
+function s(e) {
+	let t = Math.max(50, Math.floor(e.maxRows / 10));
+	if (e.rows.length <= e.maxRows + t) return;
+	e.rows.splice(0, e.rows.length - e.maxRows);
+	let n = /* @__PURE__ */ new Set();
+	for (let t of e.rows) "id" in t.event && n.add(t.event.id);
+	for (let t of Object.values(e.current)) t.acts.forEach((e) => n.add(e));
+	e.pending.forEach((e) => n.add(e.id));
+	for (let t of Object.keys(e.spans)) n.has(t) || delete e.spans[t];
+}
+function c(e) {
+	e.rows.splice(0, e.rows.length);
+}
+function l(e, t) {
+	let n = e, r = [];
+	for (let e = t.length - 1; e >= 0; e--) {
+		let i = t[e], a = n, o = n[i.from];
+		i.type === "reply" && o?.acts.includes(i.id) && (n = {
+			...n,
+			[i.from]: {
+				...o,
+				acts: o.acts.filter((e) => e !== i.id)
+			}
+		}), r.push({
+			id: `g-${i.id}`,
+			pending: i,
+			pre: a,
+			post: n
+		});
+	}
+	return r;
+}
+function u(e, t) {
+	let n = [];
+	for (let r of Object.values(e.spans)) r.parent === t && n.push(r.id);
+	return n.sort((t, n) => e.spans[t].start - e.spans[n].start);
+}
+function d(e, t, n) {
+	if (t === n) return !0;
+	for (let t of Object.values(e.pre)) if (t.acts.includes(n)) return !0;
+	for (let t of Object.values(e.post)) if (t.acts.includes(n)) return !0;
+	return !1;
+}
+function f(e) {
+	let t = new Date(e), n = (e, t = 2) => String(e).padStart(t, "0");
+	return `${n(t.getHours())}:${n(t.getMinutes())}:${n(t.getSeconds())}.${n(t.getMilliseconds(), 3)}`;
+}
+function p(e, t, n = Date.now()) {
+	if (t.kind === "state") {
+		let n = e.rows.find((e) => e.id === t.rowId);
+		return !n || n.event.type !== "state" ? t.id : `${t.lane} → ${n.event.state} at ${f(n.event.ts)}`;
+	}
+	if (t.kind === "pending") {
+		let r = e.pending.find((e) => e.id === t.id);
+		if (!r) return "already fulfilled";
+		let i = n - r.since, a = r.type === "reply" ? "reply" : "message", o = r.timeoutMs ? ` / timeout ${r.timeoutMs} ms${i > r.timeoutMs ? " · OVERDUE" : ""}` : "";
+		return `expected ${a} ${r.from} → ${r.to}: "${r.label}" · waiting ${i} ms${o}`;
+	}
+	let r = e.spans[t.id];
+	if (!r) return t.id;
+	let i = r.end == null ? `running ${n - r.start} ms` : `${r.end - r.start} ms`, a = r.result ? ` (${r.result})` : "";
+	return t.kind === "activity" ? `${r.to} handling "${r.label}" from ${r.from} · started ${f(r.start)} · ${i}${a}` : `${r.kind.toUpperCase()} ${r.from} → ${r.to}: "${r.label}" · ${r.status}${a} · ${i}`;
+}
+function m(n, r, i) {
+	e(n, (e, t) => {
+		t.modelId === r && a(i(e), t.events);
+	}), t(n, (e, t) => {
+		t.modelId === r && c(i(e));
+	});
+}
+//#endregion
+export { c as clearSwimlaneRows, n as createSwimlaneModel, p as describeSwimlaneTarget, f as formatTs, a as ingestSwimlaneEvents, l as projectPending, m as registerSwimlaneModel, u as relatedCallIds, d as rowTouches };
+
+//# sourceMappingURL=swimlane.model.js.map

package/cards/swimlane/swimlane.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swimlane.model.js","names":[],"sources":["../../../src/cards/swimlane/swimlane.model.ts"],"sourcesContent":["/**\n * Swimlane model helpers — pure TypeScript, no React.\n *\n * The model is plain JSON that lives in the app's Redux state.\n * `ingestSwimlaneEvents` MUTATES the model it is given, which is exactly what\n * a Pihanga (Immer) reducer wants:\n *\n *   onSwimlaneEventsReceived<AppState>(r, (state, {events}) => {\n *     ingestSwimlaneEvents(state.swimlane, events);\n *   });\n *\n * or simply `registerSwimlaneModel(r, \"main\", (s) => s.swimlane)`.\n *\n * Every row stores its own plain copies of the lane snapshots, so no object is\n * ever referenced from two places in the state tree (Immer-safe, serialisable).\n */\nimport type {PiRegister, ReduxState} from \"@pihanga2/core\";\n\nimport {\n  DEF_MAX_ROWS,\n  onSwimlaneEventsReceived,\n  onSwimlaneRowsCleared,\n  type SwimlaneEvent,\n  type SwimlaneGhostRow,\n  type SwimlaneLanesSnapshot,\n  type SwimlaneModel,\n  type SwimlanePending,\n  type SwimlaneRow,\n  type SwimlaneRowEvent,\n  type SwimlaneTarget,\n} from \"./swimlane.types\";\n\nexport function createSwimlaneModel(\n  opts: {maxRows?: number} = {},\n): SwimlaneModel {\n  return {\n    laneOrder: [],\n    laneLabels: {},\n    current: {},\n    rows: [],\n    pending: [],\n    spans: {},\n    seq: 0,\n    maxRows: opts.maxRows ?? DEF_MAX_ROWS,\n  };\n}\n\nfunction copySnapshot(s: SwimlaneLanesSnapshot): SwimlaneLanesSnapshot {\n  const out: SwimlaneLanesSnapshot = {};\n  for (const k of Object.keys(s)) {\n    out[k] = {state: s[k].state, acts: [...s[k].acts]};\n  }\n  return out;\n}\n\n/** Lanes an event refers to (used to add lanes implicitly). */\nfunction referencedLanes(m: SwimlaneModel, ev: SwimlaneEvent): string[] {\n  switch (ev.type) {\n    case \"state\":\n      return [ev.lane];\n    case \"call\":\n      return ev.from === ev.to ? [ev.from] : [ev.from, ev.to];\n    case \"expect\":\n      return ev.from === ev.to ? [ev.from] : [ev.from, ev.to];\n    case \"reply\":\n    case \"done\": {\n      const s = m.spans[ev.id];\n      return s ? [s.to, s.from] : [];\n    }\n    default:\n      return [];\n  }\n}\n\n/**\n * Apply a batch of stream events to the model (mutating it).\n * Safe to call on an Immer draft or on a plain object.\n */\nexport function ingestSwimlaneEvents(\n  m: SwimlaneModel,\n  events: SwimlaneEvent[],\n  now: number = Date.now(),\n): void {\n  for (const raw of events) {\n    const ts = raw.ts ?? now;\n    // lanes referenced before they were announced get an implicit lane row\n    for (const lane of referencedLanes(m, raw)) {\n      if (!m.current[lane]) applyOne(m, {type: \"lane\", lane}, ts);\n    }\n    applyOne(m, raw, ts);\n  }\n  trim(m);\n}\n\nfunction applyOne(m: SwimlaneModel, ev: SwimlaneEvent, ts: number): void {\n  const cur = m.current;\n\n  if (ev.type === \"expect\") {\n    m.pending.push({\n      id: ev.id,\n      type: \"expect\",\n      from: ev.from,\n      to: ev.to,\n      label: ev.label,\n      since: ts,\n      timeoutMs: ev.timeoutMs,\n    });\n    return;\n  }\n\n  const pre = copySnapshot(cur);\n  let route: SwimlaneRow[\"route\"];\n\n  switch (ev.type) {\n    case \"lane\":\n      if (ev.label) m.laneLabels[ev.lane] = ev.label;\n      if (cur[ev.lane]) return; // already known → only a label update\n      cur[ev.lane] = {state: \"created\", acts: []};\n      m.laneOrder.push(ev.lane);\n      break;\n    case \"state\":\n      cur[ev.lane].state = ev.state;\n      break;\n    case \"call\": {\n      // causality: explicit parentId, else the innermost open activity of the caller\n      const callerActs = cur[ev.from]?.acts ?? [];\n      const parent = ev.parentId ?? callerActs[callerActs.length - 1];\n      m.spans[ev.id] = {\n        id: ev.id,\n        kind: ev.kind,\n        from: ev.from,\n        to: ev.to,\n        label: ev.label,\n        start: ts,\n        end: ev.kind === \"event\" ? ts : undefined,\n        status: ev.kind === \"event\" ? \"done\" : \"open\",\n      };\n      if (parent && parent !== ev.id) m.spans[ev.id].parent = parent;\n      if (ev.kind !== \"event\") cur[ev.to].acts.push(ev.id);\n      break;\n    }\n    case \"reply\":\n    case \"done\": {\n      const s = m.spans[ev.id];\n      if (!s) return; // unknown call → nothing sensible to draw\n      s.end = ts;\n      s.status = ev.type === \"done\" ? \"done\" : ev.ok ? \"ok\" : \"error\";\n      if (ev.type === \"reply\") s.result = ev.label;\n      const lane = cur[s.to];\n      if (lane) {\n        const i = lane.acts.indexOf(ev.id);\n        if (i >= 0) lane.acts.splice(i, 1);\n      }\n      route = {from: s.from, to: s.to, label: s.label};\n      break;\n    }\n  }\n\n  // does this real event replace an outstanding one?\n  let fulfilled: string | undefined;\n  const pid = ev.type === \"reply\" ? ev.id : ev.fulfils;\n  if (pid) {\n    const i = m.pending.findIndex((p) => p.id === pid);\n    if (i >= 0) {\n      m.pending.splice(i, 1);\n      fulfilled = pid;\n    }\n  }\n  // a sync call means we KNOW a reply will come back\n  if (ev.type === \"call\" && ev.kind === \"sync\") {\n    m.pending.push({\n      id: ev.id,\n      type: \"reply\",\n      from: ev.to,\n      to: ev.from,\n      label: `reply: ${ev.label}`,\n      since: ts,\n      timeoutMs: ev.timeoutMs,\n    });\n  }\n\n  const row: SwimlaneRow = {\n    id: ++m.seq,\n    event: {...ev, ts} as SwimlaneRowEvent,\n    pre,\n    post: copySnapshot(cur),\n  };\n  if (fulfilled) row.fulfilled = fulfilled;\n  if (route) row.route = route;\n  m.rows.push(row);\n}\n\n/** Ring buffer with amortised span garbage collection. */\nfunction trim(m: SwimlaneModel): void {\n  const slack = Math.max(50, Math.floor(m.maxRows / 10));\n  if (m.rows.length <= m.maxRows + slack) return;\n  m.rows.splice(0, m.rows.length - m.maxRows);\n  const keep = new Set<string>();\n  for (const r of m.rows) {\n    if (\"id\" in r.event) keep.add(r.event.id);\n  }\n  for (const l of Object.values(m.current)) l.acts.forEach((a) => keep.add(a));\n  m.pending.forEach((p) => keep.add(p.id));\n  for (const id of Object.keys(m.spans)) {\n    if (!keep.has(id)) delete m.spans[id];\n  }\n}\n\n/** Remove all rows but keep lanes, open activities and outstanding messages. */\nexport function clearSwimlaneRows(m: SwimlaneModel): void {\n  m.rows.splice(0, m.rows.length);\n}\n\n/**\n * Project outstanding messages below the \"now\" line (pure).\n * Expected replies are replayed onto the current snapshot so that open\n * activities visibly run down to the ghost reply that will close them.\n * Newest first ≈ innermost call replies first.\n */\nexport function projectPending(\n  current: SwimlaneLanesSnapshot,\n  pending: SwimlanePending[],\n): SwimlaneGhostRow[] {\n  let snap = current;\n  const out: SwimlaneGhostRow[] = [];\n  for (let i = pending.length - 1; i >= 0; i--) {\n    const p = pending[i];\n    const pre = snap;\n    const lane = snap[p.from];\n    if (p.type === \"reply\" && lane?.acts.includes(p.id)) {\n      snap = {...snap, [p.from]: {...lane, acts: lane.acts.filter((a) => a !== p.id)}};\n    }\n    out.push({id: `g-${p.id}`, pending: p, pre, post: snap});\n  }\n  return out;\n}\n\n/**\n * Direct children of call `id`: calls made while it was being handled.\n * Their call/reply transitions (and outstanding replies) are the transitions\n * the process \"creates and receives\".\n */\nexport function relatedCallIds(m: Pick<SwimlaneModel, \"spans\">, id: string): string[] {\n  const out: string[] = [];\n  for (const s of Object.values(m.spans)) if (s.parent === id) out.push(s.id);\n  return out.sort((a, b) => m.spans[a].start - m.spans[b].start);\n}\n\n/** Does a row (or ghost row) involve the call chain `id`? */\nexport function rowTouches(\n  r: {pre: SwimlaneLanesSnapshot; post: SwimlaneLanesSnapshot},\n  eventId: string | undefined,\n  id: string,\n): boolean {\n  if (eventId === id) return true;\n  for (const l of Object.values(r.pre)) if (l.acts.includes(id)) return true;\n  for (const l of Object.values(r.post)) if (l.acts.includes(id)) return true;\n  return false;\n}\n\nexport function formatTs(t: number): string {\n  const d = new Date(t);\n  const p = (n: number, w = 2) => String(n).padStart(w, \"0\");\n  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}.${p(d.getMilliseconds(), 3)}`;\n}\n\n/** Human-readable description of a hover target (used by the tooltip). */\nexport function describeSwimlaneTarget(\n  m: SwimlaneModel,\n  t: SwimlaneTarget,\n  now: number = Date.now(),\n): string {\n  if (t.kind === \"state\") {\n    const r = m.rows.find((x) => x.id === t.rowId);\n    if (!r || r.event.type !== \"state\") return t.id;\n    return `${t.lane} → ${r.event.state} at ${formatTs(r.event.ts)}`;\n  }\n  if (t.kind === \"pending\") {\n    const p = m.pending.find((x) => x.id === t.id);\n    if (!p) return \"already fulfilled\";\n    const w = now - p.since;\n    const what = p.type === \"reply\" ? \"reply\" : \"message\";\n    const to = p.timeoutMs\n      ? ` / timeout ${p.timeoutMs} ms${w > p.timeoutMs ? \" · OVERDUE\" : \"\"}`\n      : \"\";\n    return `expected ${what} ${p.from} → ${p.to}: \"${p.label}\" · waiting ${w} ms${to}`;\n  }\n  const s = m.spans[t.id];\n  if (!s) return t.id;\n  const dur = s.end != null ? `${s.end - s.start} ms` : `running ${now - s.start} ms`;\n  const res = s.result ? ` (${s.result})` : \"\";\n  if (t.kind === \"activity\") {\n    return `${s.to} handling \"${s.label}\" from ${s.from} · started ${formatTs(s.start)} · ${dur}${res}`;\n  }\n  return `${s.kind.toUpperCase()} ${s.from} → ${s.to}: \"${s.label}\" · ${s.status}${res} · ${dur}`;\n}\n\n/**\n * Wire the data actions for one model:\n *\n *   register((r) => registerSwimlaneModel<AppState>(r, \"main\", (s) => s.swimlane));\n *   // …later, from a stream adapter:\n *   dispatchSwimlaneEvents(dispatch, {modelId: \"main\", events});\n */\nexport function registerSwimlaneModel<S extends ReduxState>(\n  r: PiRegister,\n  modelId: string,\n  select: (state: S) => SwimlaneModel,\n): void {\n  onSwimlaneEventsReceived<S>(r, (state, a) => {\n    if (a.modelId === modelId) ingestSwimlaneEvents(select(state), a.events);\n  });\n  onSwimlaneRowsCleared<S>(r, (state, a) => {\n    if (a.modelId === modelId) clearSwimlaneRows(select(state));\n  });\n}\n"],"mappings":"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"}

package/cards/swimlane/swimlane.model.test.d.ts

@@ -0,0 +1 @@
+export {};

package/cards/swimlane/swimlane.types.d.ts

@@ -0,0 +1,271 @@
+export declare const SWIMLANE_CARD = "shad/swimlane";
+export declare const Swimlane: <S extends import('@pihanga2/core').ReduxState>(p: import('@pihanga2/core').PiMapProps<SwimlaneProps, S, SwimlaneEvents>) => import('@pihanga2/core').PiCardDef;
+export declare const SWIMLANE_ACTION: {
+    ITEM_CLICKED: string;
+    HOVER_CHANGED: string;
+};
+export declare const onSwimlaneHoverChanged: <S extends import('@pihanga2/core').ReduxState>(register: import('@pihanga2/core/types').PiRegisterMinimal, f: import('@pihanga2/core').ReduceF<S, import('@pihanga2/core').ReduxAction & {
+    cardID: string;
+} & SwimlaneHoverChangedEvent>) => void;
+export declare const onSwimlaneItemClicked: <S extends import('@pihanga2/core').ReduxState>(register: import('@pihanga2/core/types').PiRegisterMinimal, f: import('@pihanga2/core').ReduceF<S, import('@pihanga2/core').ReduxAction & {
+    cardID: string;
+} & SwimlaneItemClickedEvent>) => void;
+export declare const SWIMLANE_DATA_ACTION: {
+    EVENTS_RECEIVED: string;
+    ROWS_CLEARED: string;
+};
+export declare const dispatchSwimlaneEvents: (d: import('@pihanga2/core').DispatchF, ev: SwimlaneEventsReceivedEvent) => void;
+export declare const dispatchSwimlaneRowsCleared: (d: import('@pihanga2/core').DispatchF, ev: SwimlaneRowsClearedEvent) => void;
+export declare const onSwimlaneEventsReceived: <S extends import('@pihanga2/core').ReduxState>(register: import('@pihanga2/core/types').PiRegisterMinimal, f: import('@pihanga2/core').ReduceF<S, import('@pihanga2/core').ReduxAction & {
+    cardID: string;
+} & SwimlaneEventsReceivedEvent>) => void;
+export declare const onSwimlaneRowsCleared: <S extends import('@pihanga2/core').ReduxState>(register: import('@pihanga2/core/types').PiRegisterMinimal, f: import('@pihanga2/core').ReduceF<S, import('@pihanga2/core').ReduxAction & {
+    cardID: string;
+} & SwimlaneRowsClearedEvent>) => void;
+/** Run state of a service, drawn on its lifeline. */
+export type SwimlaneRunState = "created" | "starting" | "running" | "degraded" | "stopped";
+/**
+ * How a message travels between lanes.
+ * - `sync`  – request that expects a reply; opens an activity on the target
+ *             and automatically creates an *outstanding reply*.
+ * - `async` – message that opens an activity on the target, closed by `done`.
+ * - `event` – fire-and-forget; no activity.
+ */
+export type SwimlaneCallKind = "sync" | "async" | "event";
+type SwimlaneEventBase = {
+    /** Epoch ms. Defaults to `Date.now()` at ingest time. */
+    ts?: number;
+    /** Id of an `expect` event that this real event resolves. */
+    fulfils?: string;
+};
+/** A service became known. Lanes referenced by calls are also added implicitly. */
+export type SwimlaneLaneEvent = SwimlaneEventBase & {
+    type: "lane";
+    lane: string;
+    /** Display name (defaults to `lane`). */
+    label?: string;
+};
+/** A service changed its run state. */
+export type SwimlaneStateEvent = SwimlaneEventBase & {
+    type: "state";
+    lane: string;
+    state: SwimlaneRunState;
+};
+/** A message between two lanes (or a lane and itself). */
+export type SwimlaneCallEvent = SwimlaneEventBase & {
+    type: "call";
+    /** Unique id; replies / `done` refer to it. */
+    id: string;
+    kind: SwimlaneCallKind;
+    from: string;
+    to: string;
+    label: string;
+    /** For `sync`: when the expected reply becomes overdue (ms after `ts`). */
+    timeoutMs?: number;
+    /**
+     * Id of the call whose processing caused this call (like a trace's parent
+     * span id). When omitted it is inferred at ingest time as the innermost
+     * activity open on the `from` lane — exact for sequential processing, a
+     * best guess when one service handles several requests concurrently.
+     */
+    parentId?: string;
+};
+/** Reply to an earlier `sync` call (drawn from callee back to caller). */
+export type SwimlaneReplyEvent = SwimlaneEventBase & {
+    type: "reply";
+    /** Id of the originating call. */
+    id: string;
+    ok: boolean;
+    label: string;
+};
+/** Processing of an earlier `async` call finished (closes the activity). */
+export type SwimlaneDoneEvent = SwimlaneEventBase & {
+    type: "done";
+    id: string;
+};
+/**
+ * Announces a message that is KNOWN to arrive later (from → to).
+ * Shown as an outstanding ghost row until a real event with `fulfils: id`
+ * arrives. Does not create a row itself.
+ */
+export type SwimlaneExpectEvent = SwimlaneEventBase & {
+    type: "expect";
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+    timeoutMs?: number;
+};
+export type SwimlaneEvent = SwimlaneLaneEvent | SwimlaneStateEvent | SwimlaneCallEvent | SwimlaneReplyEvent | SwimlaneDoneEvent | SwimlaneExpectEvent;
+export type SwimlaneLaneSnapshot = {
+    state: SwimlaneRunState;
+    /** Ids of calls currently being handled by this lane (stack order). */
+    acts: string[];
+};
+/** Lane id → snapshot. A lane missing from the record does not exist (yet). */
+export type SwimlaneLanesSnapshot = Record<string, SwimlaneLaneSnapshot>;
+/** A row event is any stream event except `expect` (which never makes a row). */
+export type SwimlaneRowEvent = Exclude<SwimlaneEvent, SwimlaneExpectEvent> & {
+    ts: number;
+};
+/**
+ * One rendered transition. `pre` / `post` are the lane snapshots before and
+ * after the event: the top half of the row is drawn from `pre`, the bottom
+ * half from `post`.
+ */
+export type SwimlaneRow = {
+    id: number;
+    event: SwimlaneRowEvent;
+    pre: SwimlaneLanesSnapshot;
+    post: SwimlaneLanesSnapshot;
+    /** Set when this event replaced an outstanding (expected) message. */
+    fulfilled?: string;
+    /**
+     * For `reply` / `done` rows: the originating call, resolved at ingest time
+     * so the row stays drawable after its span has been garbage-collected.
+     */
+    route?: {
+        from: string;
+        to: string;
+        label: string;
+    };
+};
+/** An outstanding message projected below the "now" line. */
+export type SwimlaneGhostRow = {
+    id: string;
+    pending: SwimlanePending;
+    pre: SwimlaneLanesSnapshot;
+    post: SwimlaneLanesSnapshot;
+};
+/** A message that is known to be coming. */
+export type SwimlanePending = {
+    id: string;
+    /** `reply` = implied by a sync call; `expect` = announced explicitly. */
+    type: "reply" | "expect";
+    from: string;
+    to: string;
+    label: string;
+    since: number;
+    timeoutMs?: number;
+};
+/** Lifecycle of a call, used for tooltips and hover payloads. */
+export type SwimlaneSpan = {
+    id: string;
+    kind: SwimlaneCallKind;
+    from: string;
+    to: string;
+    label: string;
+    start: number;
+    end?: number;
+    status: "open" | "ok" | "error" | "done";
+    result?: string;
+    /** Call whose processing caused this one (explicit `parentId` or inferred). */
+    parent?: string;
+};
+export type SwimlaneModel = {
+    /** Lane ids in display (arrival) order. */
+    laneOrder: string[];
+    /** Optional display names. */
+    laneLabels: Record<string, string>;
+    /** Current snapshot (== `post` of the last row). */
+    current: SwimlaneLanesSnapshot;
+    rows: SwimlaneRow[];
+    pending: SwimlanePending[];
+    spans: Record<string, SwimlaneSpan>;
+    /** Last assigned row id. */
+    seq: number;
+    /** Ring-buffer size for `rows`. */
+    maxRows: number;
+};
+export type SwimlaneProps = {
+    /** The model to render — usually a state selector `(s) => s.swimlane`. */
+    model: SwimlaneModel;
+    /** Show outstanding messages below the "now" line. Default `true`. */
+    showPending?: boolean;
+    /**
+     * Keep the newest row in view while the user is at the bottom of the
+     * scroll container. Scrolling up pauses following. Default `true`.
+     */
+    autoFollow?: boolean;
+    /** Show the built-in hover tooltip. Default `true`. */
+    showTooltip?: boolean;
+    /**
+     * Highlight a call chain (call, activity, reply, outstanding reply) by id,
+     * in addition to whatever the pointer is hovering.
+     */
+    highlightId?: string;
+    /** Horizontal distance between lifelines in px. Default 104. */
+    laneWidth?: number;
+    /** Height of each transition row in px. Default 30. */
+    rowHeight?: number;
+    /** Height of the header holding the vertical lane names. Default 130. */
+    headerHeight?: number;
+    /** Width of the left timestamp column in px. Default 92. */
+    gutterWidth?: number;
+    /** `top` offset for the sticky header (e.g. height of a navbar). Default 0. */
+    stickyTop?: number;
+    /**
+     * Clock (epoch ms) used for "waiting …" timers and overdue detection of
+     * outstanding messages. When omitted the card ticks its own wall clock
+     * (4×/s, only while something is outstanding). Pass it to drive the card
+     * entirely from props — e.g. for replaying a recorded trace or for tests.
+     */
+    now?: number;
+    className?: string;
+};
+/** What the pointer is over. */
+export type SwimlaneTargetKind = "transition" | "activity" | "state" | "pending";
+export type SwimlaneTarget = {
+    kind: SwimlaneTargetKind;
+    /** Call id (transition/activity/pending) or `state-<rowId>` (state). */
+    id: string;
+    lane?: string;
+    rowId?: number;
+};
+export type SwimlaneHoverChangedEvent = {
+    /** New hover target, or `null` when the pointer left all targets. */
+    target: SwimlaneTarget | null;
+    /** Target that was hovered before, if any. */
+    previous: SwimlaneTarget | null;
+    /** Span details for the new target (when it refers to a call). */
+    span?: SwimlaneSpan;
+    /** Outstanding message details when `target.kind === "pending"`. */
+    pending?: SwimlanePending;
+    /**
+     * Calls made while handling the hovered call (its direct children). Their
+     * call and reply transitions are highlighted as well.
+     */
+    related?: string[];
+    /**
+     * For a hovered transition: call id of the caller-side process (activity)
+     * that sent the call and receives its reply. That activity is highlighted.
+     */
+    process?: string;
+    clientX?: number;
+    clientY?: number;
+};
+export type SwimlaneItemClickedEvent = {
+    target: SwimlaneTarget;
+    span?: SwimlaneSpan;
+    pending?: SwimlanePending;
+    related?: string[];
+    process?: string;
+};
+export type SwimlaneEvents = {
+    onHoverChanged: SwimlaneHoverChangedEvent;
+    onItemClicked: SwimlaneItemClickedEvent;
+};
+export type SwimlaneEventsReceivedEvent = {
+    /** Which model to update (apps may show several swimlanes). */
+    modelId: string;
+    events: SwimlaneEvent[];
+};
+export type SwimlaneRowsClearedEvent = {
+    modelId: string;
+};
+export declare const DEF_LANE_WIDTH = 104;
+export declare const DEF_ROW_HEIGHT = 30;
+export declare const DEF_HEADER_HEIGHT = 130;
+export declare const DEF_GUTTER_WIDTH = 92;
+export declare const DEF_MAX_ROWS = 2000;
+export {};

package/cards/swimlane/swimlane.types.js

@@ -0,0 +1,7 @@
+import { createCardDeclaration as e, createOnAction as t, createOnDispatch as n, registerActions as r } from "@pihanga2/core";
+//#region src/cards/swimlane/swimlane.types.ts
+var i = "shad/swimlane", a = e(i), o = r(i, ["hover_changed", "item_clicked"]), s = t(o.HOVER_CHANGED), c = t(o.ITEM_CLICKED), l = r(`${i}/data`, ["events_received", "rows_cleared"]), u = n(l.EVENTS_RECEIVED), d = n(l.ROWS_CLEARED), f = t(l.EVENTS_RECEIVED), p = t(l.ROWS_CLEARED), m = 104, h = 30, g = 130, _ = 92, v = 2e3;
+//#endregion
+export { _ as DEF_GUTTER_WIDTH, g as DEF_HEADER_HEIGHT, m as DEF_LANE_WIDTH, v as DEF_MAX_ROWS, h as DEF_ROW_HEIGHT, o as SWIMLANE_ACTION, i as SWIMLANE_CARD, l as SWIMLANE_DATA_ACTION, a as Swimlane, u as dispatchSwimlaneEvents, d as dispatchSwimlaneRowsCleared, f as onSwimlaneEventsReceived, s as onSwimlaneHoverChanged, c as onSwimlaneItemClicked, p as onSwimlaneRowsCleared };
+
+//# sourceMappingURL=swimlane.types.js.map

package/cards/swimlane/swimlane.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swimlane.types.js","names":[],"sources":["../../../src/cards/swimlane/swimlane.types.ts"],"sourcesContent":["import {\n  createCardDeclaration,\n  createOnAction,\n  createOnDispatch,\n  registerActions,\n} from \"@pihanga2/core\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Card identity\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport const SWIMLANE_CARD = \"shad/swimlane\";\n\nexport const Swimlane = createCardDeclaration<SwimlaneProps, SwimlaneEvents>(\n  SWIMLANE_CARD,\n);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Actions EMITTED by the card (user interaction)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport const SWIMLANE_ACTION = registerActions(SWIMLANE_CARD, [\n  \"hover_changed\",\n  \"item_clicked\",\n]);\n\nexport const onSwimlaneHoverChanged = createOnAction<SwimlaneHoverChangedEvent>(\n  SWIMLANE_ACTION.HOVER_CHANGED,\n);\n\nexport const onSwimlaneItemClicked = createOnAction<SwimlaneItemClickedEvent>(\n  SWIMLANE_ACTION.ITEM_CLICKED,\n);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Actions CONSUMED by the app (feeding the model).\n//\n// These are not emitted by the card. They are a convenience so that stream\n// adapters (WebSocket, SSE, polling …) can push events with a typed dispatcher\n// and apps can wire the model with a single `registerSwimlaneModel()` call\n// (see swimlane.model.ts).\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport const SWIMLANE_DATA_ACTION = registerActions(`${SWIMLANE_CARD}/data`, [\n  \"events_received\",\n  \"rows_cleared\",\n]);\n\nexport const dispatchSwimlaneEvents =\n  createOnDispatch<SwimlaneEventsReceivedEvent>(\n    SWIMLANE_DATA_ACTION.EVENTS_RECEIVED,\n  );\nexport const dispatchSwimlaneRowsCleared =\n  createOnDispatch<SwimlaneRowsClearedEvent>(SWIMLANE_DATA_ACTION.ROWS_CLEARED);\n\nexport const onSwimlaneEventsReceived =\n  createOnAction<SwimlaneEventsReceivedEvent>(\n    SWIMLANE_DATA_ACTION.EVENTS_RECEIVED,\n  );\nexport const onSwimlaneRowsCleared = createOnAction<SwimlaneRowsClearedEvent>(\n  SWIMLANE_DATA_ACTION.ROWS_CLEARED,\n);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Incoming stream events (what a monitored deployment reports)\n// All timestamps are epoch milliseconds; `ts` is filled in on ingest if absent.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Run state of a service, drawn on its lifeline. */\nexport type SwimlaneRunState =\n  | \"created\"\n  | \"starting\"\n  | \"running\"\n  | \"degraded\"\n  | \"stopped\";\n\n/**\n * How a message travels between lanes.\n * - `sync`  – request that expects a reply; opens an activity on the target\n *             and automatically creates an *outstanding reply*.\n * - `async` – message that opens an activity on the target, closed by `done`.\n * - `event` – fire-and-forget; no activity.\n */\nexport type SwimlaneCallKind = \"sync\" | \"async\" | \"event\";\n\ntype SwimlaneEventBase = {\n  /** Epoch ms. Defaults to `Date.now()` at ingest time. */\n  ts?: number;\n  /** Id of an `expect` event that this real event resolves. */\n  fulfils?: string;\n};\n\n/** A service became known. Lanes referenced by calls are also added implicitly. */\nexport type SwimlaneLaneEvent = SwimlaneEventBase & {\n  type: \"lane\";\n  lane: string;\n  /** Display name (defaults to `lane`). */\n  label?: string;\n};\n\n/** A service changed its run state. */\nexport type SwimlaneStateEvent = SwimlaneEventBase & {\n  type: \"state\";\n  lane: string;\n  state: SwimlaneRunState;\n};\n\n/** A message between two lanes (or a lane and itself). */\nexport type SwimlaneCallEvent = SwimlaneEventBase & {\n  type: \"call\";\n  /** Unique id; replies / `done` refer to it. */\n  id: string;\n  kind: SwimlaneCallKind;\n  from: string;\n  to: string;\n  label: string;\n  /** For `sync`: when the expected reply becomes overdue (ms after `ts`). */\n  timeoutMs?: number;\n  /**\n   * Id of the call whose processing caused this call (like a trace's parent\n   * span id). When omitted it is inferred at ingest time as the innermost\n   * activity open on the `from` lane — exact for sequential processing, a\n   * best guess when one service handles several requests concurrently.\n   */\n  parentId?: string;\n};\n\n/** Reply to an earlier `sync` call (drawn from callee back to caller). */\nexport type SwimlaneReplyEvent = SwimlaneEventBase & {\n  type: \"reply\";\n  /** Id of the originating call. */\n  id: string;\n  ok: boolean;\n  label: string;\n};\n\n/** Processing of an earlier `async` call finished (closes the activity). */\nexport type SwimlaneDoneEvent = SwimlaneEventBase & {\n  type: \"done\";\n  id: string;\n};\n\n/**\n * Announces a message that is KNOWN to arrive later (from → to).\n * Shown as an outstanding ghost row until a real event with `fulfils: id`\n * arrives. Does not create a row itself.\n */\nexport type SwimlaneExpectEvent = SwimlaneEventBase & {\n  type: \"expect\";\n  id: string;\n  from: string;\n  to: string;\n  label: string;\n  timeoutMs?: number;\n};\n\nexport type SwimlaneEvent =\n  | SwimlaneLaneEvent\n  | SwimlaneStateEvent\n  | SwimlaneCallEvent\n  | SwimlaneReplyEvent\n  | SwimlaneDoneEvent\n  | SwimlaneExpectEvent;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Model (lives in the app's Redux state; plain JSON)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SwimlaneLaneSnapshot = {\n  state: SwimlaneRunState;\n  /** Ids of calls currently being handled by this lane (stack order). */\n  acts: string[];\n};\n\n/** Lane id → snapshot. A lane missing from the record does not exist (yet). */\nexport type SwimlaneLanesSnapshot = Record<string, SwimlaneLaneSnapshot>;\n\n/** A row event is any stream event except `expect` (which never makes a row). */\nexport type SwimlaneRowEvent = Exclude<SwimlaneEvent, SwimlaneExpectEvent> & {\n  ts: number;\n};\n\n/**\n * One rendered transition. `pre` / `post` are the lane snapshots before and\n * after the event: the top half of the row is drawn from `pre`, the bottom\n * half from `post`.\n */\nexport type SwimlaneRow = {\n  id: number;\n  event: SwimlaneRowEvent;\n  pre: SwimlaneLanesSnapshot;\n  post: SwimlaneLanesSnapshot;\n  /** Set when this event replaced an outstanding (expected) message. */\n  fulfilled?: string;\n  /**\n   * For `reply` / `done` rows: the originating call, resolved at ingest time\n   * so the row stays drawable after its span has been garbage-collected.\n   */\n  route?: {from: string; to: string; label: string};\n};\n\n/** An outstanding message projected below the \"now\" line. */\nexport type SwimlaneGhostRow = {\n  id: string;\n  pending: SwimlanePending;\n  pre: SwimlaneLanesSnapshot;\n  post: SwimlaneLanesSnapshot;\n};\n\n/** A message that is known to be coming. */\nexport type SwimlanePending = {\n  id: string;\n  /** `reply` = implied by a sync call; `expect` = announced explicitly. */\n  type: \"reply\" | \"expect\";\n  from: string;\n  to: string;\n  label: string;\n  since: number;\n  timeoutMs?: number;\n};\n\n/** Lifecycle of a call, used for tooltips and hover payloads. */\nexport type SwimlaneSpan = {\n  id: string;\n  kind: SwimlaneCallKind;\n  from: string;\n  to: string;\n  label: string;\n  start: number;\n  end?: number;\n  status: \"open\" | \"ok\" | \"error\" | \"done\";\n  result?: string;\n  /** Call whose processing caused this one (explicit `parentId` or inferred). */\n  parent?: string;\n};\n\nexport type SwimlaneModel = {\n  /** Lane ids in display (arrival) order. */\n  laneOrder: string[];\n  /** Optional display names. */\n  laneLabels: Record<string, string>;\n  /** Current snapshot (== `post` of the last row). */\n  current: SwimlaneLanesSnapshot;\n  rows: SwimlaneRow[];\n  pending: SwimlanePending[];\n  spans: Record<string, SwimlaneSpan>;\n  /** Last assigned row id. */\n  seq: number;\n  /** Ring-buffer size for `rows`. */\n  maxRows: number;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Card props & events\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SwimlaneProps = {\n  /** The model to render — usually a state selector `(s) => s.swimlane`. */\n  model: SwimlaneModel;\n\n  /** Show outstanding messages below the \"now\" line. Default `true`. */\n  showPending?: boolean;\n\n  /**\n   * Keep the newest row in view while the user is at the bottom of the\n   * scroll container. Scrolling up pauses following. Default `true`.\n   */\n  autoFollow?: boolean;\n\n  /** Show the built-in hover tooltip. Default `true`. */\n  showTooltip?: boolean;\n\n  /**\n   * Highlight a call chain (call, activity, reply, outstanding reply) by id,\n   * in addition to whatever the pointer is hovering.\n   */\n  highlightId?: string;\n\n  /** Horizontal distance between lifelines in px. Default 104. */\n  laneWidth?: number;\n  /** Height of each transition row in px. Default 30. */\n  rowHeight?: number;\n  /** Height of the header holding the vertical lane names. Default 130. */\n  headerHeight?: number;\n  /** Width of the left timestamp column in px. Default 92. */\n  gutterWidth?: number;\n  /** `top` offset for the sticky header (e.g. height of a navbar). Default 0. */\n  stickyTop?: number;\n\n  /**\n   * Clock (epoch ms) used for \"waiting …\" timers and overdue detection of\n   * outstanding messages. When omitted the card ticks its own wall clock\n   * (4×/s, only while something is outstanding). Pass it to drive the card\n   * entirely from props — e.g. for replaying a recorded trace or for tests.\n   */\n  now?: number;\n\n  className?: string;\n};\n\n/** What the pointer is over. */\nexport type SwimlaneTargetKind = \"transition\" | \"activity\" | \"state\" | \"pending\";\n\nexport type SwimlaneTarget = {\n  kind: SwimlaneTargetKind;\n  /** Call id (transition/activity/pending) or `state-<rowId>` (state). */\n  id: string;\n  lane?: string;\n  rowId?: number;\n};\n\nexport type SwimlaneHoverChangedEvent = {\n  /** New hover target, or `null` when the pointer left all targets. */\n  target: SwimlaneTarget | null;\n  /** Target that was hovered before, if any. */\n  previous: SwimlaneTarget | null;\n  /** Span details for the new target (when it refers to a call). */\n  span?: SwimlaneSpan;\n  /** Outstanding message details when `target.kind === \"pending\"`. */\n  pending?: SwimlanePending;\n  /**\n   * Calls made while handling the hovered call (its direct children). Their\n   * call and reply transitions are highlighted as well.\n   */\n  related?: string[];\n  /**\n   * For a hovered transition: call id of the caller-side process (activity)\n   * that sent the call and receives its reply. That activity is highlighted.\n   */\n  process?: string;\n  clientX?: number;\n  clientY?: number;\n};\n\nexport type SwimlaneItemClickedEvent = {\n  target: SwimlaneTarget;\n  span?: SwimlaneSpan;\n  pending?: SwimlanePending;\n  related?: string[];\n  process?: string;\n};\n\nexport type SwimlaneEvents = {\n  onHoverChanged: SwimlaneHoverChangedEvent;\n  onItemClicked: SwimlaneItemClickedEvent;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Data-action payloads\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SwimlaneEventsReceivedEvent = {\n  /** Which model to update (apps may show several swimlanes). */\n  modelId: string;\n  events: SwimlaneEvent[];\n};\n\nexport type SwimlaneRowsClearedEvent = {\n  modelId: string;\n};\n\nexport const DEF_LANE_WIDTH = 104;\nexport const DEF_ROW_HEIGHT = 30;\nexport const DEF_HEADER_HEIGHT = 130;\nexport const DEF_GUTTER_WIDTH = 92;\nexport const DEF_MAX_ROWS = 2000;\n"],"mappings":";;AAWA,IAAa,IAAgB,iBAEhB,IAAW,EACtB,CACF,GAMa,IAAkB,EAAgB,GAAe,CAC5D,iBACA,cACF,CAAC,GAEY,IAAyB,EACpC,EAAgB,aAClB,GAEa,IAAwB,EACnC,EAAgB,YAClB,GAWa,IAAuB,EAAgB,GAAG,EAAc,QAAQ,CAC3E,mBACA,cACF,CAAC,GAEY,IACX,EACE,EAAqB,eACvB,GACW,IACX,EAA2C,EAAqB,YAAY,GAEjE,IACX,EACE,EAAqB,eACvB,GACW,IAAwB,EACnC,EAAqB,YACvB,GA4Sa,IAAiB,KACjB,IAAiB,IACjB,IAAoB,KACpB,IAAmB,IACnB,IAAe"}