@alfadocs/ui-kit 1.3.13 → 1.4.0

package/dist/_chunks/pregnancy-dating-BmpHScZ0.js

@@ -0,0 +1,770 @@
+import { jsxs as i, jsx as a, Fragment as Ne } from "react/jsx-runtime";
+import { forwardRef as xe, useState as c, useMemo as y, useEffect as Le, useRef as ke } from "react";
+import { c as Me } from "./index-D2ZczOXr.js";
+import { useTranslation as Re } from "react-i18next";
+import { u as Te } from "./registry-DvAUVLHh.js";
+import { R as u } from "./radio-TWf9Q-mp.js";
+import { R as j } from "./radio-group-CI-6SmSw.js";
+import { F as f } from "./form-field-M5UpX65Z.js";
+import { D as V } from "./date-picker-Bp64zk2p.js";
+import { N as H } from "./number-input-DOe5VYei.js";
+import { S as Ce } from "./select-BW5ecXlX.js";
+import { S as je } from "./switch-OILsBLWo.js";
+import { C as ie } from "./card-DPmk26CL.js";
+import { B as $ } from "./badge-DCOqV9mI.js";
+import { I as Ee } from "./insert-result-D074GtHX.js";
+import { D as E, r as Pe, c as Oe, g as _e, e as Ie, f as Fe, A as Ge, h as Ke, i as Ve, j as le, G as He } from "./antenatal-schedule-timeline-u8TsS2QJ.js";
+import { s as P } from "./subDays-CAUv47M1.js";
+import { c as q } from "./date-picker-variants-pKAJfnWr.js";
+import { p as $e } from "./parseISO-fOGpHKXm.js";
+import { f as qe } from "./format-4HNwNGrN.js";
+const B = {
+  type: "string",
+  pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+}, Be = {
+  id: "pregnancy-dating",
+  // set_value → the seven `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, datingAdjustment: number | null, asOfDate: string }",
+      descriptionKey: "ui.agent.pregnancyDating.state.inputs",
+      description: "The dating inputs as entered — anchor method, its reference date, cycle length (LMP), embryo age (IVF), the optional CRL + scan date, the manual ±days nudge, and the evaluation date. Dates are `yyyy-MM-dd`. Read this to see which method a reference date will be interpreted under.",
+      read: (n) => n.getInputs()
+    },
+    result: {
+      type: "{ dueDate: string, gestationalStart: string, gestationalAge: { weeks: number, days: number, totalDays: number } | null, trimester: string } | null",
+      descriptionKey: "ui.agent.pregnancyDating.state.result",
+      description: "Computed estimated delivery date, the GA day-0 anchor after any re-dating or adjustment, the gestational age in completed weeks + days as of the evaluation date, and the trimester band (preconception / first / second / third / postterm). Null until a reference date is set.",
+      read: (n) => n.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' | 'edd' }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          method: {
+            enum: ["lmp", "conception", "ivf", "edd"],
+            description: "Which anchor to date from — last menstrual period, conception, IVF transfer, or a known estimated delivery date."
+          }
+        },
+        required: ["method"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the method was applied."
+      },
+      errors: [
+        "Returns false for a method outside the four supported anchors."
+      ],
+      examples: [
+        { args: { method: "edd" }, note: "Date backwards from a known EDD." }
+      ],
+      descriptionKey: "ui.agent.pregnancyDating.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 — only a known EDD may be in the future.",
+      invoke: (n, s) => n.setMethod(s.method)
+    },
+    set_reference_date: {
+      safety: "write",
+      argsType: "{ date: string | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          date: {
+            oneOf: [
+              { ...B, description: "Local calendar date, `yyyy-MM-dd`." },
+              { type: "null" }
+            ],
+            description: "The date the active method anchors on — LMP, conception, transfer, or known EDD — or null to clear it. Only a known EDD may be in the future."
+          }
+        },
+        required: ["date"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the date was applied."
+      },
+      errors: [
+        "Returns false for an unparseable date, or for a future date under any method but `edd` — the on-screen DatePicker caps those at today."
+      ],
+      examples: [
+        {
+          args: { date: "2026-01-12" },
+          note: "Under the default LMP method, a last period starting 12 January."
+        }
+      ],
+      descriptionKey: "ui.agent.pregnancyDating.actions.setReferenceDate",
+      description: "Set the reference date for the active method. This is the only required input — the result stays null without it.",
+      invoke: (n, s) => n.setReferenceDate(s.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,
+      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.pregnancyDating.actions.setCycleLength",
+      description: "LMP method only — set the average cycle length, which shifts Naegele dating off the 28-day assumption.",
+      invoke: (n, s) => n.setCycleLength(s.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,
+      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.pregnancyDating.actions.setEmbryoAge",
+      description: "IVF method only — set the embryo age at transfer, which offsets the transfer date back to a notional LMP.",
+      invoke: (n, s) => n.setEmbryoAge(s.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: [{ ...B }, { type: "null" }],
+            description: "Date of the CRL scan (`yyyy-MM-dd`, not in the future), or null to clear it."
+          }
+        },
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      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.pregnancyDating.actions.setCrl",
+      description: "LMP method only — set the first-trimester crown-rump length and its scan date. A confirmed re-dating wins over both the cycle length and the manual adjustment.",
+      invoke: (n, s) => n.setCrl(s)
+    },
+    set_dating_adjustment: {
+      safety: "write",
+      argsType: "{ days: number | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          days: {
+            oneOf: [{ type: "integer" }, { type: "null" }],
+            description: "Whole days to nudge the dating by — positive moves the pregnancy further along — or null for no adjustment."
+          }
+        },
+        required: ["days"],
+        additionalProperties: !1
+      },
+      idempotent: !0,
+      returns: "boolean",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the value was applied."
+      },
+      errors: [
+        "Returns false for a non-integer number of days.",
+        "Applies but changes nothing while a CRL re-dating is confirmed — the measurement wins."
+      ],
+      examples: [
+        {
+          args: { days: 3 },
+          note: "An uncertain LMP judged three days earlier than entered."
+        }
+      ],
+      descriptionKey: "ui.agent.pregnancyDating.actions.setDatingAdjustment",
+      description: "Nudge the dating by whole days for an uncertain anchor. Positive moves the pregnancy further along (earlier effective LMP, earlier due date).",
+      invoke: (n, s) => n.setDatingAdjustment(s.days)
+    },
+    set_as_of_date: {
+      safety: "write",
+      argsType: "{ date: string }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          date: {
+            ...B,
+            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,
+      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.pregnancyDating.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: (n, s) => n.setAsOfDate(s.date)
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "pregnancy-dating",
+      description: "Marks the PregnancyDating 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."
+    }
+  }
+}, ze = Me("ds:flex ds:flex-col ds:gap-[var(--spacing-lg)]", {
+  variants: {
+    width: { full: "ds:w-full", auto: "ds:inline-flex" }
+  },
+  defaultVariants: { width: "full" }
+}), Ye = {
+  lmp: "pregnancyDating.lmpDate",
+  conception: "pregnancyDating.conceptionDate",
+  ivf: "pregnancyDating.transferDate",
+  edd: "pregnancyDating.eddDate"
+}, N = (n) => qe(n, "yyyy-MM-dd"), z = (n) => {
+  const s = $e(n);
+  return Number.isNaN(s.getTime()) ? null : s;
+}, O = { min: 20, max: 45 }, Ue = xe(
+  ({
+    defaultMethod: n = "lmp",
+    defaultReferenceDate: s,
+    onResultChange: x,
+    onInsert: Y,
+    insertVariant: U = "insert",
+    onCopy: oe,
+    onError: de,
+    insertBrand: ce,
+    showSchedule: _ = !1,
+    defaultPlurality: ue = "singleton",
+    defaultChorionicity: ge = "unknown",
+    defaultRhNegative: pe = !1,
+    defaultGdmRisk: me,
+    scheduleOptions: W,
+    id: J,
+    width: he,
+    className: ye
+  }, fe) => {
+    const { t, i18n: L } = Re(), [l, Q] = c(n), [d, I] = c(
+      s
+    ), [w, X] = c(
+      E
+    ), [A, Z] = c(5), [D, ee] = c(null), [b, te] = c(void 0), [v, ae] = c(
+      null
+    ), [p, ne] = c(() => /* @__PURE__ */ new Date()), [k, De] = c(ue), [F, be] = c(ge), [G, ve] = c(pe), [M, we] = c(
+      me ?? "none"
+    ), re = y(() => /* @__PURE__ */ new Date(), []), g = y(() => l !== "lmp" || !d || D === null || !b ? null : Pe({ lmp: d, scanDate: b, crlMm: D }), [l, d, D, b]), S = y(() => {
+      if (!d) return null;
+      let e, o = E;
+      l === "lmp" ? (e = d, o = w ?? E) : l === "conception" ? e = P(d, le) : l === "ivf" ? e = P(d, A + le) : e = P(d, He), l === "lmp" && (g != null && g.redated) ? (e = g.gestationalStart, o = E) : v && (e = P(e, v));
+      const m = Oe(
+        { method: "lmp", date: e, cycleLength: o },
+        p
+      );
+      return {
+        result: {
+          dueDate: m.dueDate,
+          gestationalStart: m.gestationalStart,
+          gestationalAge: m.gestationalAge,
+          trimester: m.trimester
+        },
+        milestones: _e(m.gestationalStart)
+      };
+    }, [
+      l,
+      d,
+      w,
+      A,
+      g,
+      v,
+      p
+    ]), r = (S == null ? void 0 : S.result) ?? null, R = y(() => !_ || !r ? null : Ie(r.gestationalStart, {
+      ...W,
+      today: p,
+      plurality: k,
+      chorionicity: F,
+      rhNegative: G,
+      gdmRisk: M === "none" ? void 0 : M
+    }), [
+      _,
+      r,
+      p,
+      W,
+      k,
+      F,
+      G,
+      M
+    ]), T = y(
+      () => new Intl.DateTimeFormat(L.language, { dateStyle: "long" }),
+      [L.language]
+    ), se = y(
+      () => new Intl.DateTimeFormat(L.language, { dateStyle: "medium" }),
+      [L.language]
+    );
+    Le(() => {
+      x == null || x(r);
+    }, [r, x]);
+    const C = ke({
+      method: l,
+      refDate: d,
+      cycleLength: w,
+      embryoAge: A,
+      crlMm: D,
+      scanDate: b,
+      datingAdjustment: v,
+      asOfDate: p,
+      result: r
+    });
+    C.current = {
+      method: l,
+      refDate: d,
+      cycleLength: w,
+      embryoAge: A,
+      crlMm: D,
+      scanDate: b,
+      datingAdjustment: v,
+      asOfDate: p,
+      result: r
+    };
+    const Ae = y(
+      () => ({
+        getInputs: () => {
+          const e = C.current;
+          return {
+            method: e.method,
+            referenceDate: e.refDate ? N(e.refDate) : null,
+            cycleLength: e.cycleLength,
+            embryoAge: e.embryoAge,
+            crlMm: e.crlMm,
+            scanDate: e.scanDate ? N(e.scanDate) : null,
+            datingAdjustment: e.datingAdjustment,
+            asOfDate: N(e.asOfDate)
+          };
+        },
+        getResult: () => {
+          const e = C.current.result;
+          return e ? {
+            dueDate: N(e.dueDate),
+            gestationalStart: N(e.gestationalStart),
+            gestationalAge: e.gestationalAge ? { ...e.gestationalAge } : null,
+            trimester: e.trimester
+          } : null;
+        },
+        setMethod: (e) => e !== "lmp" && e !== "conception" && e !== "ivf" && e !== "edd" ? !1 : (Q(e), !0),
+        setReferenceDate: (e) => {
+          if (e === null)
+            return I(void 0), !0;
+          const o = z(e);
+          return !o || C.current.method !== "edd" && q(o, /* @__PURE__ */ new Date()) ? !1 : (I(o), !0);
+        },
+        setCycleLength: (e) => e !== null && !(Number.isFinite(e) && e >= O.min && e <= O.max) ? !1 : (X(e), !0),
+        setEmbryoAge: (e) => e !== 3 && e !== 5 ? !1 : (Z(e), !0),
+        setCrl: (e) => {
+          const o = /* @__PURE__ */ new Date();
+          let m;
+          if ("crlMm" in e) {
+            const h = e.crlMm;
+            if (h != null && !(Number.isFinite(h) && h > 0))
+              return !1;
+          }
+          if ("scanDate" in e && e.scanDate != null) {
+            const h = z(e.scanDate);
+            if (!h || q(h, o)) return !1;
+            m = h;
+          }
+          return "crlMm" in e && ee(e.crlMm ?? null), "scanDate" in e && te(m), !0;
+        },
+        setDatingAdjustment: (e) => e !== null && !Number.isInteger(e) ? !1 : (ae(e), !0),
+        setAsOfDate: (e) => {
+          const o = z(e);
+          return o ? (ne(o), !0) : !1;
+        }
+      }),
+      []
+    );
+    Te(Be, Ae, J);
+    const Se = y(
+      () => [
+        "unknown",
+        "dichorionic-diamniotic",
+        "monochorionic-diamniotic",
+        "monochorionic-monoamniotic"
+      ].map((e) => ({
+        value: e,
+        label: t(`antenatalSchedule.chorionicity.${e}`)
+      })),
+      [t]
+    ), K = (e) => e ? t("pregnancyDating.result.gestation", {
+      weeks: e.weeks,
+      days: e.days
+    }) : "—";
+    return /* @__PURE__ */ i(
+      "div",
+      {
+        ref: fe,
+        "data-component": "pregnancy-dating",
+        "data-component-id": J,
+        className: ze({ width: he, className: ye }),
+        children: [
+          /* @__PURE__ */ i(
+            j,
+            {
+              label: t("pregnancyDating.method.label"),
+              variant: "horizontal",
+              value: l,
+              onValueChange: (e) => Q(e),
+              children: [
+                /* @__PURE__ */ a(u, { label: t("pregnancyDating.method.lmp"), value: "lmp" }),
+                /* @__PURE__ */ a(
+                  u,
+                  {
+                    label: t("pregnancyDating.method.conception"),
+                    value: "conception"
+                  }
+                ),
+                /* @__PURE__ */ a(u, { label: t("pregnancyDating.method.ivf"), value: "ivf" }),
+                /* @__PURE__ */ a(u, { label: t("pregnancyDating.method.edd"), value: "edd" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ i("div", { className: "ds:grid ds:grid-cols-1 ds:gap-[var(--spacing-md)] ds:sm:grid-cols-2", children: [
+            /* @__PURE__ */ a(f, { label: t(Ye[l]), children: /* @__PURE__ */ a(
+              V,
+              {
+                value: d,
+                onChange: I,
+                maxDate: l === "edd" ? void 0 : re
+              }
+            ) }),
+            l === "lmp" && /* @__PURE__ */ a(
+              f,
+              {
+                label: t("pregnancyDating.cycleLength"),
+                description: t("pregnancyDating.cycleLengthHint"),
+                children: /* @__PURE__ */ a(
+                  H,
+                  {
+                    mode: "integer",
+                    min: O.min,
+                    max: O.max,
+                    value: w,
+                    onChange: X
+                  }
+                )
+              }
+            ),
+            l === "ivf" && /* @__PURE__ */ i(
+              j,
+              {
+                label: t("pregnancyDating.embryoAge"),
+                variant: "horizontal",
+                value: String(A),
+                onValueChange: (e) => Z(Number(e)),
+                children: [
+                  /* @__PURE__ */ a(u, { label: t("pregnancyDating.day3"), value: "3" }),
+                  /* @__PURE__ */ a(u, { label: t("pregnancyDating.day5"), value: "5" })
+                ]
+              }
+            ),
+            /* @__PURE__ */ a(
+              f,
+              {
+                label: t("pregnancyDating.datingAdjustment"),
+                description: t("pregnancyDating.datingAdjustmentHint"),
+                children: /* @__PURE__ */ a(
+                  H,
+                  {
+                    mode: "integer",
+                    value: v,
+                    onChange: ae
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ a(
+              f,
+              {
+                label: t("pregnancyDating.asOfDate"),
+                description: t("pregnancyDating.asOfDateHint"),
+                children: /* @__PURE__ */ a(
+                  V,
+                  {
+                    value: p,
+                    onChange: (e) => e && ne(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(
+                f,
+                {
+                  label: t("pregnancyDating.crl"),
+                  description: t("pregnancyDating.crlHint"),
+                  children: /* @__PURE__ */ a(
+                    H,
+                    {
+                      mode: "decimal",
+                      min: 0,
+                      step: 0.1,
+                      value: D,
+                      onChange: ee
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ a(f, { label: t("pregnancyDating.scanDate"), children: /* @__PURE__ */ a(
+                V,
+                {
+                  value: b,
+                  onChange: te,
+                  maxDate: re
+                }
+              ) })
+            ] }),
+            g ? /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-wrap ds:items-center ds:gap-[var(--spacing-sm)]", children: [
+              /* @__PURE__ */ a($, { variant: g.redated ? "warning" : "success", children: g.redated ? t("pregnancyDating.redated", {
+                days: g.discrepancyDays
+              }) : t("pregnancyDating.datesAgree") }),
+              g.crlInRange ? null : /* @__PURE__ */ a("span", { className: "type-meta ds:text-muted-foreground", children: t("pregnancyDating.crlOutOfRange") })
+            ] }) : null
+          ] }) : null,
+          _ ? /* @__PURE__ */ i(Ne, { children: [
+            /* @__PURE__ */ i(
+              j,
+              {
+                label: t("antenatalSchedule.plurality.label"),
+                variant: "horizontal",
+                value: k,
+                onValueChange: (e) => De(e),
+                children: [
+                  /* @__PURE__ */ a(
+                    u,
+                    {
+                      label: t("antenatalSchedule.plurality.singleton"),
+                      value: "singleton"
+                    }
+                  ),
+                  /* @__PURE__ */ a(
+                    u,
+                    {
+                      label: t("antenatalSchedule.plurality.twin"),
+                      value: "twin"
+                    }
+                  ),
+                  /* @__PURE__ */ a(
+                    u,
+                    {
+                      label: t("antenatalSchedule.plurality.triplet"),
+                      value: "triplet"
+                    }
+                  )
+                ]
+              }
+            ),
+            k !== "singleton" ? /* @__PURE__ */ a(f, { label: t("antenatalSchedule.chorionicity.label"), children: /* @__PURE__ */ a(
+              Ce,
+              {
+                options: Se,
+                value: F,
+                onValueChange: (e) => be(e)
+              }
+            ) }) : null,
+            /* @__PURE__ */ a(
+              je,
+              {
+                label: t("antenatalSchedule.rhNegative"),
+                checked: G,
+                onCheckedChange: ve
+              }
+            ),
+            /* @__PURE__ */ i(
+              j,
+              {
+                label: t("antenatalSchedule.gdmRisk.label"),
+                variant: "horizontal",
+                value: M,
+                onValueChange: (e) => we(e),
+                children: [
+                  /* @__PURE__ */ a(u, { label: t("antenatalSchedule.gdmRisk.none"), value: "none" }),
+                  /* @__PURE__ */ a(
+                    u,
+                    {
+                      label: t("antenatalSchedule.gdmRisk.medium"),
+                      value: "medium"
+                    }
+                  ),
+                  /* @__PURE__ */ a(u, { label: t("antenatalSchedule.gdmRisk.high"), value: "high" })
+                ]
+              }
+            )
+          ] }) : null,
+          /* @__PURE__ */ a("p", { className: "ds:sr-only", role: "status", "aria-live": "polite", children: r ? `${t("pregnancyDating.result.dueDateLabel")}: ${T.format(
+            r.dueDate
+          )}. ${t("pregnancyDating.result.gestationLabel")}: ${K(
+            r.gestationalAge
+          )}.` : "" }),
+          S && r ? /* @__PURE__ */ a(ie, { variant: "elevated", children: /* @__PURE__ */ i(ie.Body, { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-md)]", children: [
+            /* @__PURE__ */ i("dl", { className: "ds:flex ds:flex-wrap ds:items-start ds:gap-x-[var(--spacing-xl)] ds:gap-y-[var(--spacing-md)]", children: [
+              /* @__PURE__ */ i("div", { className: "ds:basis-full 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("pregnancyDating.result.dueDateLabel") }),
+                /* @__PURE__ */ a("dd", { className: "type-metric ds:text-foreground", children: T.format(r.dueDate) })
+              ] }),
+              /* @__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("pregnancyDating.result.gestationLabel") }),
+                /* @__PURE__ */ a("dd", { className: "type-body ds:text-foreground", children: K(r.gestationalAge) })
+              ] }),
+              /* @__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("pregnancyDating.result.trimesterLabel") }),
+                /* @__PURE__ */ a("dd", { children: /* @__PURE__ */ a(
+                  $,
+                  {
+                    variant: Fe[r.trimester],
+                    size: "lg",
+                    children: t(`pregnancyDating.trimester.${r.trimester}`)
+                  }
+                ) })
+              ] })
+            ] }),
+            /* @__PURE__ */ i("div", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]", children: [
+              /* @__PURE__ */ a("span", { className: "type-label ds:text-muted-foreground", children: t("pregnancyDating.milestonesLabel") }),
+              /* @__PURE__ */ a("ul", { className: "ds:flex ds:flex-col ds:gap-[var(--spacing-xs)]", children: S.milestones.map((e) => {
+                const o = q(p, e.date);
+                return /* @__PURE__ */ i(
+                  "li",
+                  {
+                    className: "ds:flex ds:items-center ds:justify-between ds:gap-[var(--spacing-md)]",
+                    children: [
+                      /* @__PURE__ */ a("span", { className: "type-body ds:text-foreground", children: t(`pregnancyDating.milestone.${e.key}`) }),
+                      /* @__PURE__ */ i("span", { className: "ds:flex ds:items-center ds:gap-[var(--spacing-sm)]", children: [
+                        /* @__PURE__ */ a("span", { className: "type-body ds:text-muted-foreground", children: se.format(e.date) }),
+                        o ? /* @__PURE__ */ a($, { variant: "success", children: t("pregnancyDating.reached") }) : null
+                      ] })
+                    ]
+                  },
+                  e.key
+                );
+              }) })
+            ] })
+          ] }) }) : /* @__PURE__ */ a("p", { className: "type-body ds:text-muted-foreground", children: t("pregnancyDating.empty") }),
+          R ? /* @__PURE__ */ a(Ge, { events: R }) : null,
+          r && (U === "copy" || Y) ? /* @__PURE__ */ a(
+            Ee,
+            {
+              onInsert: Y,
+              variant: U,
+              onCopy: oe,
+              onError: de,
+              card: {
+                title: t("insert.title.pregnancyDating"),
+                icon: "calendar-heart",
+                highlight: T.format(r.dueDate),
+                highlightToken: Ve(r.trimester),
+                brand: ce,
+                fields: [
+                  {
+                    icon: "calendar",
+                    label: t("pregnancyDating.result.dueDateLabel"),
+                    value: T.format(r.dueDate)
+                  },
+                  {
+                    icon: "clock",
+                    label: t("pregnancyDating.result.gestationLabel"),
+                    value: K(r.gestationalAge)
+                  },
+                  {
+                    icon: "tag",
+                    label: t("pregnancyDating.result.trimesterLabel"),
+                    value: t(`pregnancyDating.trimester.${r.trimester}`)
+                  },
+                  ...R ? Ke(
+                    R,
+                    t,
+                    (e) => se.format(e)
+                  ) : []
+                ]
+              }
+            }
+          ) : null
+        ]
+      }
+    );
+  }
+);
+Ue.displayName = "PregnancyDating";
+export {
+  Ue as P
+};
+//# sourceMappingURL=pregnancy-dating-BmpHScZ0.js.map