@alfadocs/ui-kit-debug 1.3.13 → 1.4.0

package/dist/_chunks/due-date-calculator-CnkbbAej.js

@@ -0,0 +1,571 @@
+import { jsxs as i, jsx as a } from "react/jsx-runtime";
+import { forwardRef as se, useState as p, useMemo as f, useEffect as ne, useRef as le } from "react";
+import { c as oe } from "./index-D2ZczOXr.js";
+import { useTranslation as ie } from "react-i18next";
+import { u as de } from "./registry-DvAUVLHh.js";
+import { R as C } from "./radio-TWf9Q-mp.js";
+import { R as z } from "./radio-group-CI-6SmSw.js";
+import { F as w } from "./form-field-M5UpX65Z.js";
+import { D as T } from "./date-picker-Bp64zk2p.js";
+import { N as Y } from "./number-input-DOe5VYei.js";
+import { C as U } from "./card-DPmk26CL.js";
+import { B as W } from "./badge-DCOqV9mI.js";
+import { I as ce } from "./insert-result-D074GtHX.js";
+import { D as x, r as ue, c as me, e as pe, f as he, A as ge, h as fe, i as ye } from "./antenatal-schedule-timeline-u8TsS2QJ.js";
+import { c as J } from "./date-picker-variants-pKAJfnWr.js";
+import { p as De } from "./parseISO-fOGpHKXm.js";
+import { f as be } from "./format-4HNwNGrN.js";
+const y = "Superseded by the `pregnancy-dating` adapter.", R = {
+  type: "string",
+  pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+}, ve = {
+  id: "due-date-calculator",
+  // set_value → the six `set_*` actions + the `inputs` state slot.
+  capabilities: ["set_value"],
+  state: {
+    inputs: {
+      type: "{ method: string, referenceDate: string | null, cycleLength: number | null, embryoAge: 3 | 5, crlMm: number | null, scanDate: string | null, asOfDate: string }",
+      descriptionKey: "ui.agent.dueDateCalculator.state.inputs",
+      description: "The dating inputs as entered — method, its reference date, cycle length (LMP), embryo age (IVF), the optional CRL + scan date, and the evaluation date. Dates are `yyyy-MM-dd`. Read this to see which method a reference date will be interpreted under.",
+      read: (s) => s.getInputs()
+    },
+    result: {
+      type: "{ dueDate: string, gestationalStart: string, gestationalAge: { weeks: number, days: number, totalDays: number } | null, trimester: string } | null",
+      descriptionKey: "ui.agent.dueDateCalculator.state.result",
+      description: "Computed estimated delivery date, the GA day-0 anchor after any CRL re-dating, the gestational age as of the evaluation date, and the trimester band. Null until a reference date is set.",
+      read: (s) => s.getResult()
+    }
+  },
+  actions: {
+    set_method: {
+      // Drives the same local input state a user picks; nothing is persisted
+      // to a record, and the choice is reversible in the same UI.
+      safety: "write",
+      argsType: "{ method: 'lmp' | 'conception' | 'ivf' }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          method: {
+            enum: ["lmp", "conception", "ivf"],
+            description: "Which anchor to date from — last menstrual period, conception, or IVF transfer."
+          }
+        },
+        required: ["method"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the method was applied."
+      },
+      errors: [
+        "Returns false for a method outside the three supported anchors."
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setMethod",
+      description: "Choose which anchor the pregnancy is dated from. The reference date is kept and re-interpreted under the new method, so set the method first.",
+      invoke: (s, n) => s.setMethod(n.method)
+    },
+    set_reference_date: {
+      safety: "write",
+      argsType: "{ date: string | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          date: {
+            oneOf: [
+              { ...R, description: "Local calendar date, `yyyy-MM-dd`." },
+              { type: "null" }
+            ],
+            description: "The date the active method anchors on — LMP, conception, or transfer — or null to clear it. Must not be in the future."
+          }
+        },
+        required: ["date"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the date was applied."
+      },
+      errors: [
+        "Returns false for an unparseable date or a date in the future — the on-screen DatePicker caps at today."
+      ],
+      examples: [
+        {
+          args: { date: "2026-01-12" },
+          note: "Under the default LMP method, a last period starting 12 January."
+        }
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setReferenceDate",
+      description: "Set the reference date for the active method. This is the only required input — the result stays null without it.",
+      invoke: (s, n) => s.setReferenceDate(n.date)
+    },
+    set_cycle_length: {
+      safety: "write",
+      argsType: "{ days: number | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          days: {
+            oneOf: [
+              { type: "integer", minimum: 20, maximum: 45 },
+              { type: "null" }
+            ],
+            description: "Average cycle length in days (20–45), or null to fall back to the 28-day default."
+          }
+        },
+        required: ["days"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the value was applied."
+      },
+      errors: [
+        "Returns false outside 20–45 days — the same bounds the on-screen NumberInput enforces.",
+        "Applies but changes nothing unless the method is `lmp`, and is ignored once a CRL re-dating is confirmed."
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setCycleLength",
+      description: "LMP method only — set the average cycle length, which shifts Naegele dating off the 28-day assumption.",
+      invoke: (s, n) => s.setCycleLength(n.days)
+    },
+    set_embryo_age: {
+      safety: "write",
+      argsType: "{ days: 3 | 5 }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          days: {
+            enum: [3, 5],
+            description: "Embryo age at transfer in days — 3 (cleavage) or 5 (blastocyst)."
+          }
+        },
+        required: ["days"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the value was applied."
+      },
+      errors: [
+        "Returns false for any value other than 3 or 5.",
+        "Applies but changes nothing unless the method is `ivf`."
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setEmbryoAge",
+      description: "IVF method only — set the embryo age at transfer, which offsets the transfer date back to a notional LMP.",
+      invoke: (s, n) => s.setEmbryoAge(n.days)
+    },
+    set_crl: {
+      safety: "write",
+      argsType: "{ crlMm?: number | null, scanDate?: string | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          crlMm: {
+            oneOf: [{ type: "number", exclusiveMinimum: 0 }, { type: "null" }],
+            description: "Crown-rump length in millimetres, or null to clear it."
+          },
+          scanDate: {
+            oneOf: [{ ...R }, { type: "null" }],
+            description: "Date of the CRL scan (`yyyy-MM-dd`, not in the future), or null to clear it."
+          }
+        },
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the measurement was applied."
+      },
+      errors: [
+        "Returns false and writes nothing when the length is not positive or the scan date is unparseable or in the future — the payload applies all-or-nothing.",
+        "Re-dating only happens under the `lmp` method, and only when both the length and the scan date are set."
+      ],
+      examples: [
+        {
+          args: { crlMm: 42, scanDate: "2026-02-20" },
+          note: "A first-trimester CRL that may re-date the pregnancy per ACOG CO 700."
+        }
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setCrl",
+      description: "LMP method only — set the first-trimester crown-rump length and its scan date. When the two disagree with the LMP beyond the ACOG threshold, the scan re-dates the pregnancy and overrides cycle length.",
+      invoke: (s, n) => s.setCrl(n)
+    },
+    set_as_of_date: {
+      safety: "write",
+      argsType: "{ date: string }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          date: {
+            ...R,
+            description: "Date to evaluate gestational age and trimester against, `yyyy-MM-dd`. May be in the future to project forward."
+          }
+        },
+        required: ["date"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      deprecated: y,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the date was applied."
+      },
+      errors: ["Returns false for an unparseable date."],
+      examples: [
+        {
+          args: { date: "2026-09-15" },
+          note: "Project gestational age forward to an upcoming appointment."
+        }
+      ],
+      descriptionKey: "ui.agent.dueDateCalculator.actions.setAsOfDate",
+      description: "Set the date gestational age, trimester and the antenatal schedule are evaluated against. Defaults to today; the estimated delivery date itself does not depend on it.",
+      invoke: (s, n) => s.setAsOfDate(n.date)
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "due-date-calculator",
+      description: "Marks the DueDateCalculator wrapper."
+    },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop. Also the registry key — without an `id` the instance does not register and the handle-driven actions/state are unreachable."
+    }
+  }
+}, Ce = oe("ds:flex ds:flex-col ds:gap-[var(--spacing-lg)]", {
+  variants: {
+    width: { full: "ds:w-full", auto: "ds:inline-flex" }
+  },
+  defaultVariants: { width: "full" }
+}), we = {
+  lmp: "dueDateCalculator.lmpDate",
+  conception: "dueDateCalculator.conceptionDate",
+  ivf: "dueDateCalculator.transferDate"
+}, A = (s) => be(s, "yyyy-MM-dd"), k = (s) => {
+  const n = De(s);
+  return Number.isNaN(n.getTime()) ? null : n;
+}, M = { min: 20, max: 45 }, Ae = se(
+  ({
+    defaultMethod: s = "lmp",
+    onResultChange: n,
+    onInsert: E,
+    insertVariant: _ = "insert",
+    onCopy: Q,
+    onError: X,
+    insertBrand: Z,
+    showSchedule: O = !1,
+    scheduleOptions: P,
+    id: I,
+    width: ee,
+    className: te
+  }, ae) => {
+    const { t, i18n: F } = ie(), [l, j] = p(s), [c, N] = p(void 0), [D, K] = p(
+      x
+    ), [b, G] = p(5), [h, H] = p(null), [g, $] = p(void 0), B = f(() => /* @__PURE__ */ new Date(), []), [m, V] = p(() => /* @__PURE__ */ new Date()), o = f(() => l !== "lmp" || !c || h === null || !g ? null : ue({ lmp: c, scanDate: g, crlMm: h }), [l, c, h, g]), r = f(() => {
+      if (!c) return null;
+      const e = l === "lmp" && (o != null && o.redated) ? o.gestationalStart : c, d = l === "lmp" && (o != null && o.redated) ? x : D ?? x;
+      return me(
+        {
+          method: l,
+          date: e,
+          cycleLength: d,
+          embryoAge: b
+        },
+        m
+      );
+    }, [l, c, D, b, o, m]), v = f(
+      () => new Intl.DateTimeFormat(F.language, { dateStyle: "long" }),
+      [F.language]
+    );
+    ne(() => {
+      n == null || n(r);
+    }, [r, n]);
+    const S = le({
+      method: l,
+      refDate: c,
+      cycleLength: D,
+      embryoAge: b,
+      crlMm: h,
+      scanDate: g,
+      asOfDate: m,
+      result: r
+    });
+    S.current = {
+      method: l,
+      refDate: c,
+      cycleLength: D,
+      embryoAge: b,
+      crlMm: h,
+      scanDate: g,
+      asOfDate: m,
+      result: r
+    };
+    const re = f(
+      () => ({
+        getInputs: () => {
+          const e = S.current;
+          return {
+            method: e.method,
+            referenceDate: e.refDate ? A(e.refDate) : null,
+            cycleLength: e.cycleLength,
+            embryoAge: e.embryoAge,
+            crlMm: e.crlMm,
+            scanDate: e.scanDate ? A(e.scanDate) : null,
+            asOfDate: A(e.asOfDate)
+          };
+        },
+        getResult: () => {
+          const e = S.current.result;
+          return e ? {
+            dueDate: A(e.dueDate),
+            gestationalStart: A(e.gestationalStart),
+            gestationalAge: e.gestationalAge ? { ...e.gestationalAge } : null,
+            trimester: e.trimester
+          } : null;
+        },
+        setMethod: (e) => e !== "lmp" && e !== "conception" && e !== "ivf" ? !1 : (j(e), !0),
+        setReferenceDate: (e) => {
+          if (e === null)
+            return N(void 0), !0;
+          const d = k(e);
+          return !d || J(d, /* @__PURE__ */ new Date()) ? !1 : (N(d), !0);
+        },
+        setCycleLength: (e) => e !== null && !(Number.isFinite(e) && e >= M.min && e <= M.max) ? !1 : (K(e), !0),
+        setEmbryoAge: (e) => e !== 3 && e !== 5 ? !1 : (G(e), !0),
+        setCrl: (e) => {
+          const d = /* @__PURE__ */ new Date();
+          let q;
+          if ("crlMm" in e) {
+            const u = e.crlMm;
+            if (u != null && !(Number.isFinite(u) && u > 0))
+              return !1;
+          }
+          if ("scanDate" in e && e.scanDate != null) {
+            const u = k(e.scanDate);
+            if (!u || J(u, d)) return !1;
+            q = u;
+          }
+          return "crlMm" in e && H(e.crlMm ?? null), "scanDate" in e && $(q), !0;
+        },
+        setAsOfDate: (e) => {
+          const d = k(e);
+          return d ? (V(d), !0) : !1;
+        }
+      }),
+      []
+    );
+    de(ve, re, I);
+    const L = f(() => !O || !r ? null : pe(r.gestationalStart, {
+      ...P,
+      today: m
+    }), [O, r, m, P]);
+    return /* @__PURE__ */ i(
+      "div",
+      {
+        ref: ae,
+        "data-component": "due-date-calculator",
+        "data-component-id": I,
+        className: Ce({ width: ee, className: te }),
+        children: [
+          /* @__PURE__ */ i(
+            z,
+            {
+              label: t("dueDateCalculator.method.label"),
+              variant: "horizontal",
+              value: l,
+              onValueChange: (e) => j(e),
+              children: [
+                /* @__PURE__ */ a(C, { label: t("dueDateCalculator.method.lmp"), value: "lmp" }),
+                /* @__PURE__ */ a(
+                  C,
+                  {
+                    label: t("dueDateCalculator.method.conception"),
+                    value: "conception"
+                  }
+                ),
+                /* @__PURE__ */ a(C, { label: t("dueDateCalculator.method.ivf"), value: "ivf" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ i("div", { className: "ds:grid ds:grid-cols-1 ds:gap-[var(--spacing-md)] ds:sm:grid-cols-2", children: [
+            /* @__PURE__ */ a(w, { label: t(we[l]), children: /* @__PURE__ */ a(T, { value: c, onChange: N, maxDate: B }) }),
+            l === "lmp" && /* @__PURE__ */ a(
+              w,
+              {
+                label: t("dueDateCalculator.cycleLength"),
+                description: t("dueDateCalculator.cycleLengthHint"),
+                children: /* @__PURE__ */ a(
+                  Y,
+                  {
+                    mode: "integer",
+                    min: M.min,
+                    max: M.max,
+                    value: D,
+                    onChange: K
+                  }
+                )
+              }
+            ),
+            l === "ivf" && /* @__PURE__ */ i(
+              z,
+              {
+                label: t("dueDateCalculator.embryoAge"),
+                variant: "horizontal",
+                value: String(b),
+                onValueChange: (e) => G(Number(e)),
+                children: [
+                  /* @__PURE__ */ a(C, { label: t("dueDateCalculator.day3"), value: "3" }),
+                  /* @__PURE__ */ a(C, { label: t("dueDateCalculator.day5"), value: "5" })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ a(
+            w,
+            {
+              label: t("dueDateCalculator.asOfDate"),
+              description: t("dueDateCalculator.asOfDateHint"),
+              children: /* @__PURE__ */ a(T, { value: m, onChange: (e) => e && V(e) })
+            }
+          ),
+          l === "lmp" ? /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-sm)]", children: [
+            /* @__PURE__ */ i("div", { className: "ds:grid ds:grid-cols-1 ds:gap-[var(--spacing-md)] ds:sm:grid-cols-2", children: [
+              /* @__PURE__ */ a(
+                w,
+                {
+                  label: t("dueDateCalculator.crl"),
+                  description: t("dueDateCalculator.crlHint"),
+                  children: /* @__PURE__ */ a(
+                    Y,
+                    {
+                      mode: "decimal",
+                      min: 0,
+                      step: 0.1,
+                      value: h,
+                      onChange: H
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ a(w, { label: t("dueDateCalculator.scanDate"), children: /* @__PURE__ */ a(
+                T,
+                {
+                  value: g,
+                  onChange: $,
+                  maxDate: B
+                }
+              ) })
+            ] }),
+            o ? /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-wrap ds:items-center ds:gap-[var(--spacing-sm)]", children: [
+              /* @__PURE__ */ a(W, { variant: o.redated ? "warning" : "success", children: o.redated ? t("dueDateCalculator.redated", {
+                days: o.discrepancyDays
+              }) : t("dueDateCalculator.datesAgree") }),
+              o.crlInRange ? null : /* @__PURE__ */ a("span", { className: "type-meta ds:text-muted-foreground", children: t("dueDateCalculator.crlOutOfRange") })
+            ] }) : null
+          ] }) : null,
+          /* @__PURE__ */ a("p", { className: "ds:sr-only", role: "status", "aria-live": "polite", children: r ? `${t("dueDateCalculator.result.dueDateLabel")}: ${v.format(
+            r.dueDate
+          )}. ${t("dueDateCalculator.result.trimesterLabel")}: ${t(
+            `dueDateCalculator.trimester.${r.trimester}`
+          )}.` : "" }),
+          r ? /* @__PURE__ */ a(U, { variant: "elevated", children: /* @__PURE__ */ a(U.Body, { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-md)]", children: /* @__PURE__ */ i("dl", { className: "ds:grid ds:grid-cols-1 ds:gap-[var(--spacing-md)] ds:sm:grid-cols-3", children: [
+            /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-col ds:items-start ds:gap-[var(--spacing-xs)]", children: [
+              /* @__PURE__ */ a("dt", { className: "type-label ds:text-muted-foreground", children: t("dueDateCalculator.result.trimesterLabel") }),
+              /* @__PURE__ */ a("dd", { children: /* @__PURE__ */ a(
+                W,
+                {
+                  variant: he[r.trimester],
+                  size: "lg",
+                  children: t(`dueDateCalculator.trimester.${r.trimester}`)
+                }
+              ) })
+            ] }),
+            /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]", children: [
+              /* @__PURE__ */ a("dt", { className: "type-label ds:text-muted-foreground", children: t("dueDateCalculator.result.gestationLabel") }),
+              /* @__PURE__ */ a("dd", { className: "type-body ds:text-foreground", children: r.gestationalAge ? t("dueDateCalculator.result.gestation", {
+                weeks: r.gestationalAge.weeks,
+                days: r.gestationalAge.days
+              }) : "—" })
+            ] }),
+            /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]", children: [
+              /* @__PURE__ */ a("dt", { className: "type-label ds:text-muted-foreground", children: t("dueDateCalculator.result.dueDateLabel") }),
+              /* @__PURE__ */ a("dd", { className: "type-metric ds:text-foreground", children: v.format(r.dueDate) })
+            ] })
+          ] }) }) }) : /* @__PURE__ */ a("p", { className: "type-body ds:text-muted-foreground", children: t("dueDateCalculator.empty") }),
+          L ? /* @__PURE__ */ a(ge, { events: L }) : null,
+          r && (_ === "copy" || E) ? /* @__PURE__ */ a(
+            ce,
+            {
+              variant: _,
+              onInsert: E,
+              onCopy: Q,
+              onError: X,
+              card: {
+                title: t("insert.title.dueDate"),
+                icon: "calendar-heart",
+                highlight: v.format(r.dueDate),
+                // Chip tinted with the trimester's semantic token so the inserted
+                // PNG carries the same clinical-stage colour as the on-screen
+                // trimester badge — with the contrast-safe orange override for the
+                // `--warning` third trimester.
+                highlightToken: ye(r.trimester),
+                brand: Z,
+                fields: [
+                  {
+                    // The estimated date of delivery → calendar glyph.
+                    icon: "calendar",
+                    label: t("dueDateCalculator.result.dueDateLabel"),
+                    value: v.format(r.dueDate)
+                  },
+                  {
+                    // Gestational age is an elapsed duration → clock glyph.
+                    icon: "clock",
+                    label: t("dueDateCalculator.result.gestationLabel"),
+                    value: r.gestationalAge ? t("dueDateCalculator.result.gestation", {
+                      weeks: r.gestationalAge.weeks,
+                      days: r.gestationalAge.days
+                    }) : "—"
+                  },
+                  {
+                    // Trimester is a clinical-stage classification → tag.
+                    icon: "tag",
+                    label: t("dueDateCalculator.result.trimesterLabel"),
+                    value: t(`dueDateCalculator.trimester.${r.trimester}`)
+                  },
+                  // When the schedule is shown, the single Insert button carries
+                  // the exam windows too (no second button).
+                  ...L ? fe(
+                    L,
+                    t,
+                    (e) => v.format(e)
+                  ) : []
+                ]
+              }
+            }
+          ) : null
+        ]
+      }
+    );
+  }
+);
+Ae.displayName = "DueDateCalculator";
+export {
+  Ae as D
+};
+//# sourceMappingURL=due-date-calculator-CnkbbAej.js.map