@msqd/lydia 0.0.0-stage → 0.6.0

package/dist/Elements/System/ProxyNode.d.ts

@@ -0,0 +1,8 @@
+export interface ProxyNodeProps {
+    proxy: {
+        id: string;
+        name: string;
+        implementation: string;
+    };
+}
+export declare function ProxyNode({ proxy }: ProxyNodeProps): import("react/jsx-runtime").JSX.Element;

package/dist/Elements/System/ProxyNode.js

@@ -0,0 +1,10 @@
+import { jsx as t } from "react/jsx-runtime";
+import { NetworkNode as o } from "./NetworkNode.js";
+import { Badge as i } from "../../Components/Badges/Badge.js";
+function p({ proxy: e }) {
+  const r = e.implementation === "harp" ? "purple" : "green";
+  return /* @__PURE__ */ t(o, { tone: "purple", title: e.name, children: /* @__PURE__ */ t("div", { className: "flex justify-start", children: /* @__PURE__ */ t(i, { color: r, className: "text-xs", children: e.implementation.toUpperCase() }) }) });
+}
+export {
+  p as ProxyNode
+};

package/dist/Elements/System/index.d.ts

@@ -0,0 +1,9 @@
+export { NetworkMap } from "./NetworkMap.js";
+export type { NetworkMapProps, NetworkTopology, NetworkEntrypoint, NetworkProxy, NetworkEndpoint, NetworkConnection, } from "./NetworkMap.js";
+export { NetworkNode, NetworkNodeDetail } from "./NetworkNode.js";
+export type { NetworkNodeProps, NetworkNodeDetailProps } from "./NetworkNode.js";
+export { EntrypointNode, type EntrypointNodeProps } from "./EntrypointNode.js";
+export { ProxyNode, type ProxyNodeProps } from "./ProxyNode.js";
+export { EndpointNode, type EndpointNodeProps } from "./EndpointNode.js";
+export { CircuitBreakerStatus, type CircuitBreakerStatusProps } from "./CircuitBreakerStatus.js";
+export { NetworkEdges, type NetworkEdgesProps } from "./NetworkEdges.js";

package/dist/Elements/System/index.js

@@ -0,0 +1,17 @@
+import { NetworkMap as e } from "./NetworkMap.js";
+import { NetworkNode as p, NetworkNodeDetail as N } from "./NetworkNode.js";
+import { EntrypointNode as d } from "./EntrypointNode.js";
+import { ProxyNode as m } from "./ProxyNode.js";
+import { EndpointNode as k } from "./EndpointNode.js";
+import { CircuitBreakerStatus as n } from "./CircuitBreakerStatus.js";
+import { NetworkEdges as E } from "./NetworkEdges.js";
+export {
+  n as CircuitBreakerStatus,
+  k as EndpointNode,
+  d as EntrypointNode,
+  E as NetworkEdges,
+  e as NetworkMap,
+  p as NetworkNode,
+  N as NetworkNodeDetail,
+  m as ProxyNode
+};

package/dist/Elements/Tpdex/TpdexBadge.d.ts

@@ -0,0 +1,26 @@
+import { type ComponentProps } from "react";
+export interface TpdexBadgeProps extends Omit<ComponentProps<"span">, "children"> {
+    /**
+     * Response time in milliseconds, used to estimate a score when none was measured
+     */
+    responseTime?: number;
+    /**
+     * Measured TPDEX score (0-100). Pass this only when the score was measured: supplying it is what
+     * tells the badge it is showing a measurement rather than an estimate.
+     */
+    score?: number;
+    /**
+     * Whether to show the numeric score alongside the rating label
+     */
+    showScore?: boolean;
+}
+/**
+ * Badge displaying a TPDEX performance rating.
+ *
+ * A transaction that has not ended carries no score, so the badge estimates one from the response
+ * time and **says that it did**: an estimate is marked with a leading tilde and a dashed outline.
+ * The two claims must not look alike, because filtering treats an unscored transaction as matching
+ * no bounded range, so a user who reads an `A` and filters for 90 and above would otherwise watch
+ * the row vanish with nothing on screen explaining it.
+ */
+export declare function TpdexBadge({ responseTime, score, showScore, className, ...props }: TpdexBadgeProps): import("react/jsx-runtime").JSX.Element;

package/dist/Elements/Tpdex/TpdexBadge.js

@@ -0,0 +1,36 @@
+import { jsxs as i } from "react/jsx-runtime";
+import { getTpdexRating as d, getTpdexTextClassName as c, calculateTpdexScore as p } from "../../Models/Tpdex.js";
+import "react";
+import { twMerge as f } from "tailwind-merge";
+function g({ responseTime: l, score: o, showScore: n = !1, className: r, ...m }) {
+  const t = o === void 0, a = t ? p(l || 0) : o, e = d(a), s = `${e.label}, ${a} out of 100`;
+  return /* @__PURE__ */ i(
+    "span",
+    {
+      className: f(
+        "inline-flex items-center rounded font-medium px-2 py-0.5 text-xs",
+        e.className,
+        c(e),
+        // Outline rather than border, so an estimate occupies exactly the same space as a
+        // measurement and a column of badges does not jog sideways.
+        t && "outline-dashed outline-1 -outline-offset-2 outline-white/70",
+        r
+      ),
+      role: "img",
+      "aria-label": t ? `Estimated TPDEX ${s}, from response time` : `TPDEX ${s}`,
+      title: t ? `TPDEX ${e.label} (${a}/100), estimated from response time: this transaction has no measured score yet` : `TPDEX Score: ${a}/100 (${e.label})`,
+      ...m,
+      children: [
+        t ? `~${e.label}` : e.label,
+        n && /* @__PURE__ */ i("span", { className: "ml-1 opacity-90", children: [
+          "(",
+          a,
+          ")"
+        ] })
+      ]
+    }
+  );
+}
+export {
+  g as TpdexBadge
+};

package/dist/Elements/Tpdex/index.d.ts

@@ -0,0 +1,4 @@
+export { TpdexBadge } from "./TpdexBadge.js";
+export type { TpdexBadgeProps } from "./TpdexBadge.js";
+export { tpdexScale, getTpdexRating, getTpdexTextClassName } from "../../Models/Tpdex.js";
+export type { TpdexRating } from "../../Models/Tpdex.js";

package/dist/Elements/Tpdex/index.js

@@ -0,0 +1,8 @@
+import { TpdexBadge as x } from "./TpdexBadge.js";
+import { getTpdexRating as a, getTpdexTextClassName as d, tpdexScale as g } from "../../Models/Tpdex.js";
+export {
+  x as TpdexBadge,
+  a as getTpdexRating,
+  d as getTpdexTextClassName,
+  g as tpdexScale
+};

package/dist/Elements/Transactions/TransactionFiltersCard.d.ts

@@ -0,0 +1,41 @@
+import { FacetListCard } from "../../Components/Facets/index.js";
+import type { FilterChangeHandler, Filters } from "../../Models/Filters/index.js";
+import type { TransactionFacets } from "../../Models/Transactions/facets.js";
+import { type ComponentProps } from "react";
+export interface TransactionFiltersCardProps extends Omit<ComponentProps<typeof FacetListCard>, "children" | "filters" | "onFiltersChange" | "onResetFilters"> {
+    /** Current filter values using unified Filters type */
+    filters: Filters;
+    /** Unified filter change handler */
+    onFiltersChange: FilterChangeHandler;
+    /** Handler for resetting all filters */
+    onResetFilters: () => void;
+    /** Custom title for the filters card */
+    title?: string;
+    /** Whether to show default header */
+    showDefaultHeader?: boolean;
+    /**
+     * Values each facet can offer, with their counts. Only the consumer knows what exists in the
+     * whole result set, so a facet with no entry here offers nothing rather than something invented.
+     */
+    facets?: TransactionFacets;
+}
+/**
+ * TransactionFiltersCard lays out the facets a transaction list can be narrowed by.
+ *
+ * It knows which facets exist and how they are presented. It does not know what values they can
+ * offer: those come from the consumer, because only the consumer sees the whole result set. A
+ * facet given no options renders empty, which is honest, rather than offering endpoints nobody
+ * called and counts nobody measured.
+ *
+ * @example
+ * ```tsx
+ * <TransactionFiltersCard
+ *   filters={filters}
+ *   onFiltersChange={handleFilterChange}
+ *   onResetFilters={() => setFilters({})}
+ *   title="Filter Transactions"
+ *   showDefaultHeader
+ * />
+ * ```
+ */
+export declare function TransactionFiltersCard({ filters, onFiltersChange, onResetFilters, title, showDefaultHeader, facets, ...cardProps }: TransactionFiltersCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/Elements/Transactions/TransactionFiltersCard.js

@@ -0,0 +1,121 @@
+import { jsxs as i, jsx as a } from "react/jsx-runtime";
+import { canonicalStatusToken as s } from "../../Models/Transactions/encoding.js";
+import "react";
+import { FacetListCard as c } from "../../Components/Facets/FacetListCard.js";
+import { DateRangeFacet as l } from "../../Components/Facets/Variants/DateRangeFacet.js";
+import { MultipleChoiceFacet as u } from "../../Components/Facets/Variants/MultipleChoiceFacet.js";
+import { PerformanceFacet as O } from "../../Components/Facets/Variants/PerformanceFacet.js";
+function j({
+  filters: t,
+  onFiltersChange: e,
+  onResetFilters: n,
+  title: m = "Filters",
+  showDefaultHeader: p = !0,
+  facets: o = {},
+  ...r
+}) {
+  const d = Array.isArray(t.status) ? { ...t, status: t.status.map(s) } : t;
+  return /* @__PURE__ */ i(
+    c,
+    {
+      filters: t,
+      onResetFilters: n,
+      title: m,
+      showDefaultHeader: p,
+      ...r,
+      children: [
+        /* @__PURE__ */ a(
+          l,
+          {
+            name: "time",
+            title: "Time",
+            filters: t,
+            onFiltersChange: e,
+            startDatePlaceholder: "Start date",
+            endDatePlaceholder: "End date",
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "endpoint",
+            title: "Endpoint",
+            filters: t,
+            onFiltersChange: e,
+            options: o.endpoint,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "method",
+            title: "Method",
+            filters: t,
+            onFiltersChange: e,
+            options: o.method,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "status",
+            title: "Status",
+            filters: d,
+            onFiltersChange: e,
+            options: o.status,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "cacheStatus",
+            title: "Cache Status",
+            filters: t,
+            onFiltersChange: e,
+            options: o.cacheStatus,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "flags",
+            title: "Flags",
+            filters: t,
+            onFiltersChange: e,
+            options: o.flags,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          u,
+          {
+            name: "tags",
+            title: "Tags",
+            filters: t,
+            onFiltersChange: e,
+            options: o.tags,
+            defaultOpen: !0
+          }
+        ),
+        /* @__PURE__ */ a(
+          O,
+          {
+            name: "tpdex",
+            title: "Performance Index",
+            filters: t,
+            onFiltersChange: e,
+            defaultOpen: !0
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  j as TransactionFiltersCard
+};

package/dist/Elements/Transactions/TransactionsExplorerSidebar.d.ts

@@ -0,0 +1,37 @@
+import { type EndpointNodeType, type Selection } from "../../Models/Transactions/endpoints.js";
+import type { Transaction } from "../../Models/Transactions/types.js";
+import { type ComponentProps } from "react";
+export interface TreeNode {
+    id: string;
+    name: string;
+    path: string;
+    type: EndpointNodeType;
+    apiName: string;
+    /** Path segments below the API, empty for the API node. */
+    segments: string[];
+    children?: TreeNode[];
+    transactionCount?: number;
+}
+export interface TransactionsExplorerSidebarProps extends Omit<ComponentProps<"div">, "onSelect"> {
+    /** Transaction data to build the tree from */
+    transactions: Transaction[];
+    /** Currently selected node */
+    selected?: Selection | null;
+    /** Expanded node ids. When omitted the sidebar keeps its own, and `onToggleExpand` only reports. */
+    expandedNodes?: Set<string>;
+    /** Handler when a node is selected */
+    onSelect?: (selection: Selection) => void;
+    /** Handler when a node is expanded/collapsed */
+    onToggleExpand?: (nodeId: string) => void;
+    /** Custom title for the sidebar */
+    title?: string;
+}
+/** One pass over the transactions: a trie per API, each node counting the transactions at or below it. */
+declare function buildApiTree(transactions: Transaction[]): TreeNode[];
+/**
+ * TransactionsExplorerSidebar provides a hierarchical tree view of API endpoints.
+ * Features the same clean design as other sidebar components in the Elements namespace.
+ */
+export declare function TransactionsExplorerSidebar({ transactions, selected, expandedNodes: controlledExpandedNodes, onSelect, onToggleExpand, title, className, ...props }: TransactionsExplorerSidebarProps): import("react/jsx-runtime").JSX.Element;
+export { buildApiTree };
+export type { Selection };

package/dist/Elements/Transactions/TransactionsExplorerSidebar.js

@@ -0,0 +1,154 @@
+import { jsxs as g, jsx as n } from "react/jsx-runtime";
+import { ChevronDownIcon as E, ChevronRightIcon as T, DocumentIcon as j, FolderOpenIcon as y, FolderIcon as N } from "@heroicons/react/24/outline";
+import { apiOf as I, segmentsOf as M } from "../../Models/Transactions/endpoints.js";
+import { MAX_TREE_DEPTH as f } from "../../Models/Transactions/treeDepth.js";
+import { useState as O, useMemo as A } from "react";
+import { twMerge as w } from "tailwind-merge";
+function v(e) {
+  return { type: e.type, apiName: e.apiName, segments: e.segments };
+}
+const P = (e, i) => e.apiName === i.apiName && e.segments.length === i.segments.length && e.segments.every((l, t) => l === i.segments[t]);
+function S(e) {
+  const i = /* @__PURE__ */ new Map();
+  for (const t of e) {
+    const r = I(t);
+    let a = i.get(r);
+    a || (a = { count: 0, children: /* @__PURE__ */ new Map() }, i.set(r, a)), a.count++;
+    let s = a;
+    const o = M(t);
+    (o.length > f ? [...o.slice(0, f), o.slice(f).join("/")] : o).forEach((d, u) => {
+      let m = s.children.get(d);
+      m || (m = { count: 0, children: /* @__PURE__ */ new Map(), folded: u === f ? o : void 0 }, s.children.set(d, m)), m.count++, s = m;
+    });
+  }
+  const l = (t, r, a) => [...a.children].map(([s, o]) => {
+    const c = o.folded ?? [...r, s], d = l(t, c, o);
+    return {
+      id: [t, ...c].join("/"),
+      name: s,
+      path: [t, ...c].join("/"),
+      type: d.length > 0 ? "folder" : "endpoint",
+      apiName: t,
+      segments: c,
+      children: d.length > 0 ? d : void 0,
+      transactionCount: o.count
+    };
+  });
+  return [...i].map(
+    ([t, r]) => ({
+      id: t,
+      name: t,
+      path: t,
+      type: "api",
+      apiName: t,
+      segments: [],
+      children: l(t, [], r),
+      transactionCount: r.count
+    })
+  ).sort((t, r) => t.name.localeCompare(r.name));
+}
+function b({
+  node: e,
+  level: i = 0,
+  selected: l,
+  expandedNodes: t,
+  onSelect: r,
+  onToggleExpand: a
+}) {
+  const s = t.has(e.id), o = l !== null && P(l, v(e)), c = e.children && e.children.length > 0, d = () => {
+    r(v(e)), c && a(e.id);
+  }, u = (h) => {
+    h.stopPropagation(), a(e.id);
+  }, m = () => {
+    switch (e.type) {
+      case "api":
+        return s ? /* @__PURE__ */ n(y, { className: "h-4 w-4 text-blue-500" }) : /* @__PURE__ */ n(N, { className: "h-4 w-4 text-blue-500" });
+      case "folder":
+        return s ? /* @__PURE__ */ n(y, { className: "h-4 w-4 text-yellow-500" }) : /* @__PURE__ */ n(N, { className: "h-4 w-4 text-yellow-500" });
+      case "endpoint":
+        return /* @__PURE__ */ n(j, { className: "h-4 w-4 text-gray-400" });
+    }
+  };
+  return /* @__PURE__ */ g("div", { children: [
+    /* @__PURE__ */ g(
+      "div",
+      {
+        className: w(
+          "flex items-center px-2 py-1 cursor-pointer hover:bg-gray-100 rounded text-sm",
+          o && "bg-blue-50 hover:bg-blue-100"
+        ),
+        style: { paddingLeft: `${i * 1.5 + 0.5}rem` },
+        onClick: d,
+        children: [
+          c && // Named by its node, with the state in `aria-expanded` rather than in
+          // the name: an icon alone left a screen reader saying "button".
+          /* @__PURE__ */ n(
+            "button",
+            {
+              type: "button",
+              onClick: u,
+              "aria-label": e.name,
+              "aria-expanded": s,
+              className: "p-0.5 hover:bg-gray-200 rounded mr-1",
+              children: s ? /* @__PURE__ */ n(E, { className: "h-3 w-3", "aria-hidden": "true" }) : /* @__PURE__ */ n(T, { className: "h-3 w-3", "aria-hidden": "true" })
+            }
+          ),
+          !c && /* @__PURE__ */ n("div", { className: "w-5 mr-1" }),
+          /* @__PURE__ */ g("div", { className: "flex items-center space-x-2 flex-1", children: [
+            m(),
+            /* @__PURE__ */ n("span", { className: w("truncate", o && "font-medium"), children: e.name }),
+            e.transactionCount !== void 0 && /* @__PURE__ */ n("span", { className: "text-[11px] text-gray-600 font-light ml-auto", children: e.transactionCount })
+          ] })
+        ]
+      }
+    ),
+    c && s && /* @__PURE__ */ n("div", { children: e.children.map((h) => /* @__PURE__ */ n(
+      b,
+      {
+        node: h,
+        level: i + 1,
+        selected: l,
+        expandedNodes: t,
+        onSelect: r,
+        onToggleExpand: a
+      },
+      h.id
+    )) })
+  ] });
+}
+function L({
+  transactions: e,
+  selected: i = null,
+  expandedNodes: l,
+  onSelect: t = () => {
+  },
+  onToggleExpand: r,
+  title: a = "API Endpoints",
+  className: s,
+  ...o
+}) {
+  const [c, d] = O(/* @__PURE__ */ new Set()), u = l ?? c, m = (p) => {
+    l || d((C) => {
+      const x = new Set(C);
+      return x.delete(p) || x.add(p), x;
+    }), r?.(p);
+  }, h = A(() => S(e), [e]);
+  return /* @__PURE__ */ g("div", { className: w("bg-white rounded-lg shadow overflow-hidden flex flex-col", s), ...o, children: [
+    /* @__PURE__ */ n("div", { className: "px-4 py-3 border-b border-gray-200 bg-gray-50", children: /* @__PURE__ */ n("div", { className: "flex items-center justify-between", children: /* @__PURE__ */ n("h3", { className: "text-sm font-medium text-gray-900", children: a }) }) }),
+    /* @__PURE__ */ n("div", { className: "flex-1 overflow-y-auto p-2", children: h.length === 0 ? /* @__PURE__ */ n("p", { className: "text-sm text-gray-500 p-4 text-center", children: "No APIs found" }) : h.map((p) => /* @__PURE__ */ n(
+      b,
+      {
+        node: p,
+        selected: i,
+        expandedNodes: u,
+        onSelect: t,
+        onToggleExpand: m
+      },
+      p.id
+    )) })
+  ] });
+}
+export {
+  L as TransactionsExplorerSidebar,
+  S as buildApiTree
+};

package/dist/Elements/Transactions/TransactionsFiltersSidebar.d.ts

@@ -0,0 +1,22 @@
+import { type FilterChangeHandler, type Filters } from "../../Models/Filters/index.js";
+import { type ComponentProps } from "react";
+import { TransactionFiltersCard } from "./TransactionFiltersCard.js";
+export interface TransactionsFiltersSidebarProps extends Omit<ComponentProps<typeof TransactionFiltersCard>, "filters" | "onFiltersChange" | "onResetFilters"> {
+    /** Current filter values using unified Filters type */
+    filters: Filters;
+    /** Unified filter change handler */
+    onFiltersChange: FilterChangeHandler;
+    /** Handler for resetting all filters */
+    onResetFilters: () => void;
+    /** Custom title for the sidebar */
+    title?: string;
+    /** Whether to show default header */
+    showDefaultHeader?: boolean;
+    /** Custom className for the container */
+    className?: string;
+}
+/**
+ * TransactionsFiltersSidebar component that provides transaction filtering in a sidebar layout.
+ * Designed to match the ExplorerPage tree view aesthetic with clean header and count displays.
+ */
+export declare function TransactionsFiltersSidebar({ filters, onFiltersChange, onResetFilters, facets, title, showDefaultHeader, className, ...props }: TransactionsFiltersSidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/Elements/Transactions/TransactionsFiltersSidebar.js

@@ -0,0 +1,39 @@
+import { jsxs as i, jsx as e } from "react/jsx-runtime";
+import { HeadingLevel as c } from "../../Components/Typography/HeadingLevel.js";
+import "react";
+import { twMerge as m } from "tailwind-merge";
+import { TransactionFiltersCard as f } from "./TransactionFiltersCard.js";
+import { countActiveFilters as p } from "../../Models/Filters/active.js";
+import { FacetResetLink as h } from "../../Components/Facets/FacetResetLink.js";
+function F({
+  filters: t,
+  onFiltersChange: l,
+  onResetFilters: r,
+  facets: a,
+  title: o = "Filters",
+  showDefaultHeader: u = !0,
+  className: s,
+  ...d
+}) {
+  const n = p(t);
+  return /* @__PURE__ */ i("div", { className: m("bg-white rounded-lg shadow overflow-hidden flex flex-col", s), ...d, children: [
+    /* @__PURE__ */ e("div", { className: "px-4 py-3 border-b border-gray-200 bg-gray-50", children: /* @__PURE__ */ i("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ e("h3", { className: "text-sm font-medium text-gray-900", children: o }),
+      n > 0 && r && /* @__PURE__ */ e(h, { title: "all filters", onReset: r, children: "reset all" })
+    ] }) }),
+    /* @__PURE__ */ e("div", { className: "flex-1 overflow-y-auto p-2", children: /* @__PURE__ */ e(c, { level: 3, children: /* @__PURE__ */ e(
+      f,
+      {
+        filters: t,
+        onFiltersChange: l,
+        onResetFilters: r,
+        facets: a,
+        showDefaultHeader: !1,
+        skipCardWrapper: !0
+      }
+    ) }) })
+  ] });
+}
+export {
+  F as TransactionsFiltersSidebar
+};

package/dist/Elements/Transactions/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Transaction Elements
+ *
+ * Domain-specific components for working with transaction data.
+ * These components provide higher-level abstractions that combine
+ * UI components with transaction-specific business logic.
+ */
+export { TransactionFiltersCard } from "./TransactionFiltersCard.js";
+export type { TransactionFiltersCardProps } from "./TransactionFiltersCard.js";
+export { TransactionsFiltersSidebar } from "./TransactionsFiltersSidebar.js";
+export type { TransactionsFiltersSidebarProps } from "./TransactionsFiltersSidebar.js";
+export { TransactionsExplorerSidebar, buildApiTree } from "./TransactionsExplorerSidebar.js";
+export type { Selection, TransactionsExplorerSidebarProps, TreeNode } from "./TransactionsExplorerSidebar.js";

package/dist/Elements/Transactions/index.js

@@ -0,0 +1,9 @@
+import { TransactionFiltersCard as o } from "./TransactionFiltersCard.js";
+import { TransactionsFiltersSidebar as i } from "./TransactionsFiltersSidebar.js";
+import { TransactionsExplorerSidebar as s, buildApiTree as n } from "./TransactionsExplorerSidebar.js";
+export {
+  o as TransactionFiltersCard,
+  s as TransactionsExplorerSidebar,
+  i as TransactionsFiltersSidebar,
+  n as buildApiTree
+};

package/dist/Elements/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Elements Namespace
+ *
+ * This namespace contains domain-specific component compositions that combine
+ * basic UI components with business logic and data models. Elements provide
+ * higher-level abstractions that are specialized for specific use cases
+ * while maintaining consistency with the overall design system.
+ *
+ * Elements are organized by domain:
+ * - Transactions: Components for working with transaction data
+ * - System: Components for system architecture visualization
+ * - Http: Badges for HTTP method / status / cache
+ * - Tpdex: The TPDEX performance badge
+ */
+export * from "./Transactions/index.js";
+export * from "./System/index.js";
+export * from "./Http/index.js";
+export * from "./Tpdex/index.js";

package/dist/Elements/index.js

@@ -0,0 +1,38 @@
+import { CacheBadge as o } from "./Http/CacheBadge.js";
+import { CacheIndicator as p } from "./Http/CacheIndicator.js";
+import { CircuitBreakerStatus as x } from "./System/CircuitBreakerStatus.js";
+import { EndpointNode as m } from "./System/EndpointNode.js";
+import { EntrypointNode as i } from "./System/EntrypointNode.js";
+import { NetworkEdges as n } from "./System/NetworkEdges.js";
+import { NetworkMap as c } from "./System/NetworkMap.js";
+import { NetworkNode as T, NetworkNodeDetail as l } from "./System/NetworkNode.js";
+import { ProxyNode as u } from "./System/ProxyNode.js";
+import { RequestMethodBadge as C } from "./Http/RequestMethodBadge.js";
+import { ResponseStatusBadge as w } from "./Http/ResponseStatusBadge.js";
+import { TpdexBadge as b } from "./Tpdex/TpdexBadge.js";
+import { TransactionFiltersCard as R } from "./Transactions/TransactionFiltersCard.js";
+import { TransactionsExplorerSidebar as F, buildApiTree as M } from "./Transactions/TransactionsExplorerSidebar.js";
+import { TransactionsFiltersSidebar as A } from "./Transactions/TransactionsFiltersSidebar.js";
+import { getTpdexRating as I, getTpdexTextClassName as P, tpdexScale as j } from "../Models/Tpdex.js";
+export {
+  o as CacheBadge,
+  p as CacheIndicator,
+  x as CircuitBreakerStatus,
+  m as EndpointNode,
+  i as EntrypointNode,
+  n as NetworkEdges,
+  c as NetworkMap,
+  T as NetworkNode,
+  l as NetworkNodeDetail,
+  u as ProxyNode,
+  C as RequestMethodBadge,
+  w as ResponseStatusBadge,
+  b as TpdexBadge,
+  R as TransactionFiltersCard,
+  F as TransactionsExplorerSidebar,
+  A as TransactionsFiltersSidebar,
+  M as buildApiTree,
+  I as getTpdexRating,
+  P as getTpdexTextClassName,
+  j as tpdexScale
+};

package/dist/Models/Filters/active.d.ts

@@ -0,0 +1,12 @@
+import type { Filters } from "./types.js";
+/**
+ * Number of individually selected filter values, counting each bound of a range and each
+ * selected choice of a facet. An empty selection and an unset bound are not
+ * selections, so a facet the user has not touched contributes nothing.
+ */
+export declare function countActiveFilters(filters: Filters | undefined): number;
+/**
+ * Whether the user has narrowed the results at all, by a facet or by the search term. Tells an
+ * empty result set that matched nothing apart from one that has nothing to show yet.
+ */
+export declare function hasActiveFilters(filters: Filters | undefined, search: string | undefined): boolean;

package/dist/Models/Filters/active.js

@@ -0,0 +1,10 @@
+function n(e) {
+  return e ? Object.values(e).reduce((t, r) => Array.isArray(r) ? t + r.length : typeof r == "object" && r !== null ? t + Object.values(r).filter((i) => i != null && i !== "").length : r != null && r !== "" ? t + 1 : t, 0) : 0;
+}
+function c(e, t) {
+  return n(e) > 0 || (t ?? "").trim() !== "";
+}
+export {
+  n as countActiveFilters,
+  c as hasActiveFilters
+};