@alfadocs/ui-kit 1.1.0 → 1.3.0

package/dist/_chunks/sparkline-BTY4B5tv.js

@@ -0,0 +1,509 @@
+import { jsx as c, jsxs as D } from "react/jsx-runtime";
+import { forwardRef as le, useId as ue, useMemo as A, useRef as P, useState as F, useEffect as U, useImperativeHandle as pe } from "react";
+import { c as E } from "./index-D2ZczOXr.js";
+import { useTranslation as me } from "react-i18next";
+import he from "react-apexcharts";
+import V from "apexcharts";
+import { g as J, u as fe } from "./apexcharts-theme-B_AxGC_h.js";
+import { m as ge } from "./annotation-marker-CsUJGZjQ.js";
+import { u as ve } from "./registry-DvAUVLHh.js";
+function ye(n) {
+  if (n.length < 2)
+    return { slope: 0, direction: "steady" };
+  const r = n.length, h = (r - 1) / 2, l = n.reduce((a, i) => a + i, 0) / r;
+  let s = 0, u = 0;
+  for (let a = 0; a < r; a++) {
+    const i = a - h;
+    s += i * (n[a] - l), u += i * i;
+  }
+  const m = u === 0 ? 0 : s / u, k = 0.01 * (Math.max(...n) - Math.min(...n) || 1), f = Math.abs(m) < k ? "steady" : m > 0 ? "increasing" : "decreasing";
+  return { slope: m, direction: f };
+}
+const be = {
+  id: "sparkline",
+  capabilities: [],
+  state: {},
+  actions: {
+    update_series: {
+      // Replacing the rendered series mutates what the chart displays — write,
+      // not read.
+      safety: "write",
+      argsType: "{ data: number[] }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          data: {
+            type: "array",
+            items: { type: "number" },
+            description: "The new data points to render."
+          }
+        },
+        required: ["data"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.sparkline.actions.updateSeries",
+      description: "Replace the sparkline data without remounting.",
+      invoke: (n, r) => {
+        n.updateSeries(r.data);
+      }
+    },
+    export_png: {
+      // Pure getter — returns an image of the current chart, no state change.
+      safety: "read",
+      returns: "string",
+      returnsSchema: {
+        type: "string",
+        description: "A PNG image of the sparkline encoded as a data URI."
+      },
+      descriptionKey: "ui.agent.sparkline.actions.exportPng",
+      description: "Return a PNG data URI of the sparkline.",
+      invoke: (n) => n.dataURI()
+    },
+    select_annotation: {
+      // Routes the host somewhere — the same thing a pointer press on the
+      // annotation's band does. Nothing in the chart changes, but the host's
+      // surface does, so it is not a read.
+      safety: "write",
+      argsType: "{ annotationId: string }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          annotationId: {
+            type: "string",
+            description: "The annotation's id, as carried by data-annotation-hit-id on the pressable band. The decorative drawn marker carries the same value as data-annotation-id, but is not selectable."
+          }
+        },
+        required: ["annotationId"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.sparkline.actions.selectAnnotation",
+      description: "Select a drawn annotation, as pressing its band would. No-op unless the host wired onAnnotationSelect and the id names an annotation that is currently drawn.",
+      invoke: (n, r) => {
+        n.selectAnnotation(r.annotationId);
+      }
+    }
+  },
+  domHooks: {
+    root: { attr: "data-component", value: "sparkline" },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+}, Q = E("ds:relative ds:inline-block ds:w-full", {
+  variants: {
+    size: {
+      xs: "ds:h-6",
+      sm: "ds:h-8",
+      md: "ds:h-10",
+      // Applied when an explicit `height` prop is given: the wrapper
+      // grows with the svg instead of clipping at the size's fixed height.
+      auto: ""
+    }
+  },
+  defaultVariants: { size: "md" }
+}), X = E("", {
+  variants: {
+    tone: {
+      neutral: "ds:[--annotation-color:var(--muted-foreground)]",
+      info: "ds:[--annotation-color:var(--info)]",
+      success: "ds:[--annotation-color:var(--success)]",
+      /* `--warning-readable`, not `--warning`: a 1.5px dashed line is a
+       * non-text graphic (WCAG 1.4.11, 3:1), and yellow-500 is ~1.6:1 on a
+       * light card. The token aliases back to `--warning` in dark. */
+      warning: "ds:[--annotation-color:var(--warning-readable)]",
+      error: "ds:[--annotation-color:var(--destructive)]",
+      accent: "ds:[--annotation-color:var(--accent)]"
+    }
+  },
+  defaultVariants: { tone: "neutral" }
+}), we = E(
+  "ds:pointer-events-none ds:absolute ds:inset-x-[2px]",
+  {
+    variants: {
+      // Bleed to the target-size token, not a literal: (token − drawn)/−2 per
+      // size, so `.theme-accessible` (48px) widens the band automatically —
+      // the same calc idiom IconButton uses for its hit-area expansion.
+      size: {
+        xs: "ds:inset-y-[calc((var(--min-target-size)-24px)/-2)]",
+        sm: "ds:inset-y-[calc((var(--min-target-size)-32px)/-2)]",
+        md: "ds:inset-y-[calc((var(--min-target-size)-40px)/-2)]",
+        auto: "ds:inset-y-0"
+      }
+    },
+    defaultVariants: { size: "md" }
+  }
+), ke = {
+  increasing: "↑",
+  decreasing: "↓",
+  steady: "→"
+}, xe = {
+  xs: 24,
+  sm: 32,
+  md: 40
+}, I = 2, Y = 2.5, ee = 44;
+function Ie(n, r, h = ee) {
+  const l = n.map((s) => ({
+    annotation: s,
+    centre: te(s.position) * r
+  })).sort((s, u) => s.centre - u.centre);
+  return l.map((s, u) => {
+    const m = l[u - 1], w = l[u + 1], k = m ? (m.centre + s.centre) / 2 : 0, f = w ? (s.centre + w.centre) / 2 : r, a = Math.max(0, k), i = Math.min(r, f), y = Math.min(h, Math.max(0, i - a)), N = Math.min(
+      Math.max(s.centre - y / 2, a),
+      i - y
+    );
+    return { annotation: s.annotation, x: N, width: y };
+  });
+}
+function te(n) {
+  return Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
+}
+function Ne(n) {
+  return n.filter((r) => r != null);
+}
+function Me() {
+  return typeof window < "u" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+const Te = le(
+  ({
+    id: n,
+    data: r,
+    variant: h = "line",
+    size: l = "md",
+    label: s,
+    color: u,
+    showEndpoint: m = !1,
+    showTooltip: w = !1,
+    width: k,
+    height: f,
+    annotations: a,
+    onAnnotationSelect: i,
+    className: y,
+    ...N
+  }, ne) => {
+    var Z;
+    const { t: v, i18n: W } = me(), $ = ue(), x = A(
+      () => `sparkline-${$.replace(/[^a-zA-Z0-9-_]/g, "")}`,
+      [$]
+    ), M = P(null), [C, ae] = F(0), [re, se] = F(ee), p = A(() => Ne(r), [r]), { direction: O } = ye(p), j = A(() => {
+      const e = a && a.length > 0 ? v("sparkline.annotations", {
+        list: a.map((b) => b.label).join(", ")
+      }) : "", t = (b) => e ? `${b}. ${e}` : b;
+      if (p.length === 0)
+        return t(v("sparkline.noData", "No data"));
+      const o = (b) => new Intl.NumberFormat(W.language).format(b), g = v(`sparkline.direction.${O}`), d = {
+        min: o(Math.min(...p)),
+        max: o(Math.max(...p)),
+        current: o(p[p.length - 1]),
+        direction: g
+      };
+      return t(s ? v("sparkline.summary", { label: s, ...d }) : v("sparkline.summaryNoLabel", d));
+    }, [p, a, s, O, W.language, v]), [T, ie] = F(
+      () => {
+        try {
+          return J();
+        } catch {
+          return {};
+        }
+      }
+    );
+    U(() => {
+      let e;
+      const t = new MutationObserver(() => {
+        clearTimeout(e), e = setTimeout(() => {
+          try {
+            ie(J());
+          } catch {
+          }
+        }, 50);
+      });
+      return t.observe(document.documentElement, {
+        attributes: !0,
+        attributeFilter: ["class"]
+      }), () => {
+        clearTimeout(e), t.disconnect();
+      };
+    }, []), U(() => {
+      const e = M.current;
+      if (!e) return;
+      const t = () => {
+        const g = getComputedStyle(e).getPropertyValue("--min-target-size"), d = Number.parseFloat(g);
+        Number.isFinite(d) && d > 0 && se(d);
+      };
+      t();
+      const o = new ResizeObserver((g) => {
+        const d = g[0];
+        d && ae(Math.floor(d.contentRect.width)), t();
+      });
+      return o.observe(e), () => o.disconnect();
+    }, []), fe(M);
+    const R = P(i);
+    U(() => {
+      R.current = i;
+    }, [i]);
+    const B = P(a);
+    B.current = a;
+    const H = A(
+      () => ({
+        updateSeries(e) {
+          var t;
+          (t = V.getChartByID(x)) == null || t.updateSeries([{ data: e }]);
+        },
+        updateOptions(e) {
+          var t;
+          (t = V.getChartByID(x)) == null || t.updateOptions(e);
+        },
+        async dataURI() {
+          const e = V.getChartByID(x);
+          return e ? (await e.dataURI()).imgURI : "";
+        },
+        selectAnnotation(e) {
+          var o, g;
+          (o = B.current) != null && o.some((d) => d.id === e) && ((g = R.current) == null || g.call(R, e));
+        }
+      }),
+      [x]
+    );
+    pe(ne, () => H, [H]), ve(be, H, n);
+    const _ = u ?? ((Z = T.colors) == null ? void 0 : Z[0]) ?? "currentColor";
+    if (p.length === 0)
+      return /* @__PURE__ */ c(
+        "div",
+        {
+          ref: M,
+          role: "img",
+          "aria-label": j,
+          dir: "ltr",
+          className: Q({
+            size: f !== void 0 ? "auto" : l,
+            className: y
+          }),
+          "data-component": "sparkline",
+          "data-component-id": n,
+          ...N
+        }
+      );
+    const G = Me(), S = r.length > p.length, L = S ? r.flatMap((e, t) => e == null ? [] : [{ x: t, y: e }]) : p, oe = {
+      ...T,
+      chart: {
+        ...T.chart,
+        id: x,
+        type: h,
+        sparkline: { enabled: !0 },
+        toolbar: { show: !1 },
+        animations: {
+          enabled: !G,
+          // A gapped series is re-rendered as {x, y} pairs, and Apex's
+          // update tween interpolates between the old and new paths point by
+          // point. Across a width change the two have different lengths and
+          // the tween emits `d="… NaN …"` for a few frames. The finished
+          // render is correct either way; switching the tween off keeps the
+          // console clean.
+          dynamicAnimation: { enabled: !G && !S }
+        },
+        zoom: { enabled: !1 },
+        parentHeightOffset: 0
+      },
+      colors: [_],
+      stroke: {
+        curve: "smooth",
+        width: h === "bar" ? 0 : 2
+      },
+      fill: {
+        opacity: h === "area" ? 0.15 : 1
+      },
+      xaxis: {
+        crosshairs: { show: !1 },
+        // Pin the extent to the slot count so a gap at either end still holds
+        // its place — otherwise the plot would rescale to the measurements
+        // and the annotation fractions would no longer mean the same thing.
+        ...S ? { type: "numeric", min: 0, max: r.length - 1 } : {}
+      },
+      tooltip: { enabled: w },
+      markers: m ? {
+        size: [0],
+        discrete: [
+          {
+            // An index into the SERIES, whose holes have already been
+            // removed — so this is the last MEASURED point, never a slot
+            // the parameter was not measured at.
+            seriesIndex: 0,
+            dataPointIndex: L.length - 1,
+            fillColor: _,
+            strokeColor: _,
+            size: 4
+          }
+        ]
+      } : { size: 0 },
+      grid: {
+        ...T.grid,
+        show: !1,
+        // ApexCharts grid.padding uses physical keys (not CSS logical properties).
+        // The chart wrapper enforces dir="ltr" so these always resolve correctly.
+        padding: {
+          top: I,
+          right: I,
+          bottom: I,
+          left: I
+        }
+      }
+    }, de = k ?? (C > 0 ? C : "100%"), ce = f ?? xe[l ?? "md"], z = a != null && a.length ? a : void 0, K = C - I * 2, q = i && z && K > 0 ? Ie(z, K, re) : void 0;
+    return /* @__PURE__ */ D(
+      "div",
+      {
+        ref: M,
+        role: "img",
+        "aria-label": j,
+        dir: "ltr",
+        className: Q({
+          size: f !== void 0 ? "auto" : l,
+          className: y
+        }),
+        "data-component": "sparkline",
+        "data-component-id": n,
+        ...N,
+        children: [
+          /* @__PURE__ */ c(
+            he,
+            {
+              type: h,
+              series: [{ data: L }],
+              options: oe,
+              width: de,
+              height: ce,
+              "aria-hidden": "true"
+            }
+          ),
+          z && /* Drawn over the plot rather than through ApexCharts' own xaxis
+          annotations: a fraction of the measured extent is the one
+          positioning rule that survives series of different lengths, which
+          is what makes a column of sparklines share an x. */
+          /* The inset lives on a div: an <svg> is a replaced element, so
+             left+right do not size it and it would fall back to its intrinsic
+             300px. The div is the plot box; the svg fills it. The 2px MUST
+             equal PLOT_EDGE_PADDING — Tailwind needs a static literal, so the
+             two cannot share one source; change them together or the first and
+             last annotation drift off the first and last data point. */
+          /* @__PURE__ */ c("div", { className: "ds:pointer-events-none ds:absolute ds:inset-y-0 ds:inset-x-[2px]", children: /* @__PURE__ */ c(
+            "svg",
+            {
+              "aria-hidden": "true",
+              focusable: "false",
+              "data-testid": "sparkline-annotations",
+              className: "ds:size-full",
+              children: z.map((e) => {
+                const t = te(e.position);
+                return (
+                  /* A nested viewport placed at a percentage of the plot: the
+                   one positioning rule that needs no measurement, so a column
+                   of sparklines shares an x whatever their widths. */
+                  /* @__PURE__ */ D(
+                    "svg",
+                    {
+                      x: `${t * 100}%`,
+                      y: "0",
+                      width: "1",
+                      height: "100%",
+                      overflow: "visible",
+                      "data-annotation-id": e.id,
+                      "data-annotation-position": t,
+                      className: X({ tone: e.tone }),
+                      children: [
+                        /* @__PURE__ */ c(
+                          "line",
+                          {
+                            x1: 0,
+                            x2: 0,
+                            y1: 0,
+                            y2: "100%",
+                            className: "ds:[stroke:var(--annotation-color)] ds:[stroke-dasharray:2_3] ds:[stroke-width:1]"
+                          }
+                        ),
+                        /* @__PURE__ */ c(
+                          "path",
+                          {
+                            d: ge(
+                              e.shape ?? "diamond",
+                              0,
+                              Y,
+                              Y
+                            ),
+                            className: "ds:[fill:var(--annotation-color)]"
+                          }
+                        )
+                      ]
+                    },
+                    e.id
+                  )
+                );
+              })
+            }
+          ) }),
+          q && i && /* Sized in px, not percentages: the target size is a measurement,
+          not a fraction of a box the reader can resize.
+          `pointer-events-none` holds all the way down to the bands, so the
+          only live pixels are the token-width each annotation owns. */
+          /* @__PURE__ */ c(
+            "div",
+            {
+              className: we({
+                size: f !== void 0 ? "auto" : l
+              }),
+              children: /* @__PURE__ */ c(
+                "svg",
+                {
+                  "aria-hidden": "true",
+                  focusable: "false",
+                  "data-testid": "sparkline-annotation-hits",
+                  className: "ds:size-full",
+                  children: q.map(({ annotation: e, x: t, width: o }) => /* @__PURE__ */ D(
+                    "g",
+                    {
+                      "data-annotation-hit-id": e.id,
+                      onClick: () => i(e.id),
+                      className: `ds:group ds:pointer-events-auto ds:cursor-pointer ${X(
+                        { tone: e.tone }
+                      )}`,
+                      children: [
+                        /* @__PURE__ */ c("title", { children: v("sparkline.annotationAction", {
+                          label: e.label
+                        }) }),
+                        /* @__PURE__ */ c(
+                          "rect",
+                          {
+                            x: t,
+                            y: 0,
+                            width: o,
+                            height: "100%",
+                            className: "ds:[fill:var(--annotation-color)] ds:opacity-0 ds:transition-opacity ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none ds:group-hover:opacity-20"
+                          }
+                        )
+                      ]
+                    },
+                    e.id
+                  ))
+                }
+              )
+            }
+          ),
+          m && /* @__PURE__ */ c(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "ds:pointer-events-none ds:absolute ds:end-0 ds:top-0 ds:text-[length:var(--font-size-xs)] ds:leading-none",
+              children: ke[O]
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Te.displayName = "Sparkline";
+export {
+  Te as S,
+  be as s,
+  ye as u
+};
+//# sourceMappingURL=sparkline-BTY4B5tv.js.map

package/dist/agent-catalog.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "packageVersion": "1.1.0",
+  "packageVersion": "1.3.0",
   "components": [
     {
       "kind": "component",
@@ -6720,6 +6720,12 @@
           "type": "boolean",
           "description": "Whether the current user may write clinical notes (the practice_add_clinical_note permission gate).",
           "descriptionKey": "ui.agent.notesPanel.state.canAddClinical"
+        },
+        {
+          "name": "currentNoteId",
+          "type": "string | null",
+          "description": "Id of the note the host has addressed — the one marked, scrolled to and focused. Null when none is. An id only, never note content.",
+          "descriptionKey": "ui.agent.notesPanel.state.currentNoteId"
         }
       ],
       "actions": [
@@ -11099,6 +11105,26 @@
           },
           "description": "Return a PNG data URI of the sparkline.",
           "descriptionKey": "ui.agent.sparkline.actions.exportPng"
+        },
+        {
+          "name": "select_annotation",
+          "safety": "write",
+          "argsType": "{ annotationId: string }",
+          "argsSchema": {
+            "type": "object",
+            "properties": {
+              "annotationId": {
+                "type": "string",
+                "description": "The annotation's id, as carried by data-annotation-hit-id on the pressable band. The decorative drawn marker carries the same value as data-annotation-id, but is not selectable."
+              }
+            },
+            "required": [
+              "annotationId"
+            ]
+          },
+          "idempotent": true,
+          "description": "Select a drawn annotation, as pressing its band would. No-op unless the host wired onAnnotationSelect and the id names an annotation that is currently drawn.",
+          "descriptionKey": "ui.agent.sparkline.actions.selectAnnotation"
         }
       ],
       "domHooks": {

package/dist/agent-i18n/en.json

@@ -688,7 +688,8 @@
     "notesPanel": {
       "state": {
         "notes": "Timeline note ids + pinned / flagged / clinical flags. Never the note body or author (both PHI).",
-        "canAddClinical": "Whether the current user may write clinical notes (the practice_add_clinical_note permission gate)."
+        "canAddClinical": "Whether the current user may write clinical notes (the practice_add_clinical_note permission gate).",
+        "currentNoteId": "Id of the note the host has addressed — the one marked, scrolled to and focused. Null when none is. An id only, never note content."
       },
       "actions": {
         "addNote": "Compose and commit a new note. A clinical note requires the clinical-note permission (read canAddClinical first).",
@@ -1137,7 +1138,8 @@
     "sparkline": {
       "actions": {
         "updateSeries": "Replace the sparkline data without remounting.",
-        "exportPng": "Return a PNG data URI of the sparkline."
+        "exportPng": "Return a PNG data URI of the sparkline.",
+        "selectAnnotation": "Select a drawn annotation, as pressing its band would. No-op unless the host wired onAnnotationSelect and the id names an annotation that is currently drawn."
       }
     },
     "stepperAccordion": {

package/dist/components/data-table/index.js

@@ -1,5 +1,5 @@
-import { A as r, D as l, T as t, a as s, b as n, c as o, d, e as i, f as C } from "../../_chunks/actions-cell-renderer-ClGCSQnA.js";
-import { B as T, C as F, E as g, a as b, R as u, T as c, b as m, r as f, u as x } from "../../_chunks/editable-currency-cell-renderer-Dus_sBvX.js";
+import { A as r, D as l, T as t, a as s, b as n, c as o, d, e as i, f as C } from "../../_chunks/actions-cell-renderer-Ceah0ywE.js";
+import { B as T, C as F, E as g, a as b, R as u, T as c, b as m, r as f, u as x } from "../../_chunks/editable-currency-cell-renderer-Uhzkd0ZP.js";
 import { C as p, D as h, a as y, b as E, I as S, L as A, N as L, c as N, S as B, d as I, e as P, T as U, f as W, g as k, U as v } from "../../_chunks/link-cell-renderer-_DlEZHLI.js";
 export {
   r as ActionsCellRenderer,

package/dist/components/face-scheme/index.js

@@ -1,4 +1,4 @@
-import { A as e, F as o, a as n, b as A, c as i, d as f, e as t, I, f as N, g as T, h as F, i as _, j as E, k as c, l as h, m as r, n as p, o as O, p as S, q as m, r as l, s as d, t as C, u as D } from "../../_chunks/face-scheme-Cou2efl7.js";
+import { A as e, F as o, a as n, b as A, c as i, d as f, e as t, I, f as N, g as T, h as F, i as _, j as E, k as c, l as h, m as r, n as p, o as O, p as S, q as m, r as l, s as d, t as C, u as D } from "../../_chunks/face-scheme-C00IvkUA.js";
 export {
   e as ANNOTATION_TOOL_KIND,
   o as FACE_ANNOTATION_TOOLS,

package/dist/components/file-manager/index.js

@@ -1,4 +1,4 @@
-import { F as r, f } from "../../_chunks/file-manager-CNSLiuLo.js";
+import { F as r, f } from "../../_chunks/file-manager-lNjcSXoD.js";
 export {
   r as FileManager,
   f as fileManagerAgent

package/dist/components/index.d.ts

@@ -198,6 +198,7 @@ export * from './transaction-chip';
 export * from './whatsapp-button';
 export * from './workflow';
 export * from '../patterns/alia-assistant';
+export * from '../patterns/anamnesis';
 export * from '../patterns/marketplace-app-shell';
 export * from '../patterns/payment-automation-upsell';
 export * from '../patterns/signature-request';

package/dist/components/notes-panel/index.d.ts

@@ -1,3 +1,3 @@
 export { NotesPanel } from './notes-panel';
-export type { NotesPanelProps, NotesPanelNote } from './notes-panel';
+export type { NotesPanelProps, NotesPanelNote, NotesPanelSubmission, } from './notes-panel';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/notes-panel/index.js

@@ -1,4 +1,4 @@
-import { N as a } from "../../_chunks/notes-panel-CTcOLLVo.js";
+import { N as a } from "../../_chunks/notes-panel-DPsgB4Mv.js";
 export {
   a as NotesPanel
 };