@alfadocs/ui-kit 1.15.0 → 1.16.0

package/dist/patterns/calendar/calendar-workspace.d.ts

@@ -77,6 +77,24 @@ export interface CalendarWorkspaceProps {
  * the workspace will show.
  */
 export declare function initialWorkspaceDisplay(initialDisplay: Partial<WorkspaceDisplaySettings> | undefined, preferences?: CalendarPreferenceAdapter): WorkspaceDisplaySettings;
-/** The workspace root: the read model, then the rail scope, then the page. */
+/**
+ * The workspace root: the tooltip scope, the read model, the rail scope,
+ * then the page.
+ *
+ * `TooltipProvider` is the workspace's own, not the host's. The toolbar
+ * and the panels are built from `IconButton`s carrying `tooltip`, and
+ * Radix throws `Tooltip must be used within TooltipProvider` the moment
+ * one renders with no provider in scope — which unmounts the whole React
+ * tree, so a host that simply mounts `<CalendarWorkspace />` gets a BLANK
+ * PAGE rather than a missing tooltip. A page-level pattern cannot leave
+ * that to a host that has no way of knowing which Radix primitive it
+ * happens to compose. Radix's provider is a plain scoped context: an
+ * inner one shadows the outer value for its own subtree and registers
+ * nothing globally, so a host that already has one (an app shell, the
+ * Storybook decorator, this pattern's tests) is unaffected.
+ * The delays are the kit defaults: shadowing means the workspace does not
+ * inherit a host's tuning, which is the right trade for a page that has to
+ * render at all.
+ */
 export declare function CalendarWorkspace({ data, ...props }: CalendarWorkspaceProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=calendar-workspace.d.ts.map

package/dist/patterns/calendar/calendar-workspace.model.d.ts

@@ -10,7 +10,7 @@
 import type { AppointmentItem } from '../../components/appointment-card';
 import type { CalendarResource } from '../../components/calendar';
 import type { CalendarData } from './calendar.data';
-import type { CalendarPatient, CalendarWaitingEntry } from './calendar.types';
+import { type CalendarPatient, type CalendarWaitingEntry, type PatientChannelState, type PatientRef } from './calendar.types';
 import { type CalendarRow, type DisplaySettings, type EditorDraft, type EditorPrefill, type WaitingQuickView } from './calendar.model';
 export declare const WORKSPACE_TOOL: {
     readonly appointments: "appointments";
@@ -186,14 +186,36 @@ export declare function slotConflicts(rows: readonly CalendarRow[], slot: {
 export declare function devicesForCares(cares: readonly {
     careId?: string;
 }[] | undefined, devicesByCare: Readonly<Record<string, readonly string[]>>): string[];
-/** Which sign channels a patient can take a request on. */
-export declare function signChannelsFor(patient: CalendarPatient | undefined): {
-    sms: boolean;
-    email: boolean;
+/**
+ * Which sign / notify channels a patient can take a request on — as the
+ * FOUR-state `PatientChannelState`, not a boolean.
+ *
+ * A boolean here was the bug: it folded "the record says the practice
+ * holds no number" together with "we were never told", and every caller
+ * then printed the first as the second ("No SMS-enabled number on
+ * file") for a patient the host had simply supplied without a `phone`.
+ * Callers now read the state: `channelReady` seeds a control ON,
+ * `channelOfferable` decides whether to disable it at all, and
+ * `channelReasonKey` gives a reason ONLY in the states that have one.
+ */
+export declare function signChannelStates(ref: PatientRef): {
+    sms: PatientChannelState;
+    email: PatientChannelState;
 };
 /** The platform's default: SMS when the patient can take one, else
- *  email, else nothing. */
-export declare function defaultSignMode(patient: CalendarPatient | undefined): RequiredDocsSignMode;
+ *  email, else nothing. "Can take one" is `ready` alone — a channel we
+ *  know nothing about is not a channel to send on by default. */
+export declare function defaultSignMode(ref: PatientRef): RequiredDocsSignMode;
+/** The patient's address as one line — the map link's search text, and
+ *  the link's own label. Empty when the host supplied no address at all,
+ *  which is the caller's signal to leave the map row out rather than
+ *  offer a search for nothing. */
+export declare function patientAddressLine(patient: CalendarPatient): string;
+/** The map link's own LABEL — street and city, the pair the popover has
+ *  always printed. The postcode belongs in the search query, not in the
+ *  visible text, so widening `patientAddressLine` for the URL must not
+ *  drag the label along with it. */
+export declare function patientAddressLabel(patient: CalendarPatient): string;
 /** Google Maps search for the patient's address — the popover's map link. */
 export declare function patientMapsUrl(patient: CalendarPatient): string;
 /** A CREATE mode armed by a deep link (`createParameters`) or the
@@ -291,10 +313,22 @@ export declare function upcomingAppointmentRows(rows: CalendarRow[], bounds: {
     startMs: number;
     endMs: number;
 }): CalendarRow[];
-/** One agenda row as the kit timeline's item — identity, allocation and
- *  care lines; the row id stays the event id so a click maps straight
- *  back onto the grid. */
-export declare function upcomingAppointmentItem(row: CalendarRow, privacy: boolean, data: CalendarData): AppointmentItem;
+/**
+ * One agenda row as the kit timeline's item — identity, allocation and
+ * care lines; the row id stays the event id so a click maps straight
+ * back onto the grid.
+ *
+ * The card prints its own "no patient assigned" whenever `patient` is
+ * absent, so absence here has to mean exactly that: the appointment
+ * carries NO patient id. A row that carries one but whose record the
+ * host could not resolve still names its patient — from the record, from
+ * the title the row already carries, and only then from
+ * `unresolvedPatientLabel`, which must say the record was not loaded and
+ * never that nobody is booked.
+ */
+export declare function upcomingAppointmentItem(row: CalendarRow, privacy: boolean, data: CalendarData, 
+/** Localised name-of-last-resort for an unresolvable patient id. */
+unresolvedPatientLabel: string): AppointmentItem;
 /** How far back the platform's booking query looks, on `createdAt`. */
 export declare const ONLINE_BOOKINGS_WINDOW_DAYS = 30;
 /**
@@ -355,16 +389,28 @@ export declare function waitingFiltersActiveCount(filters: WaitingListFilters):
  */
 export interface WaitingListRowView {
     entry: CalendarWaitingEntry;
-    /** Platform `patientId` / `patientName` / `patientPhoneNumber`. */
+    /** The entry's OWN patient, id and record together. `assigned` is what
+     *  decides whether this entry has a patient — the record may simply
+     *  not have loaded. */
+    patientRef: PatientRef;
+    /** Platform `patientId` / `patientName` / `patientPhoneNumber` — the
+     *  record alone, when the host could load it. */
     patient?: CalendarPatient;
     /** The linked appointment, live from the grid's rows. */
     appointment?: CalendarRow;
-    /** Platform `appointmentPatientId` — the linked appointment's patient. */
+    /** Platform `appointmentPatientId` — the linked appointment's patient,
+     *  id and record together. */
+    appointmentPatientRef: PatientRef;
+    /** The linked appointment's patient record, when it loaded. */
     appointmentPatient?: CalendarPatient;
     /** Platform `operatorName`. */
     operatorTitle?: string;
     /** Platform `appointmentName` — the linked appointment's care line. */
     appointmentName?: string;
+    /** Someone is booked on this row — the entry's own patient or the
+     *  linked appointment's. Keyed on the IDS: a record we could not load
+     *  is still a patient. */
+    patientAssigned: boolean;
     noConnection: boolean;
 }
 export declare function waitingListRowView(entry: CalendarWaitingEntry, rows: readonly CalendarRow[], data: CalendarData): WaitingListRowView;

package/dist/patterns/calendar/calendar.model.d.ts

@@ -12,7 +12,7 @@ import type { TFunction } from 'i18next';
 import { ThumbsUp } from 'lucide-react';
 import { type CalendarEvent, type CalendarEventStatus, type CalendarResource } from '../../components/calendar';
 import type { CalendarData } from './calendar.data';
-import { type CareDescriptionMode, type ColorAssociation, type CalendarBaseEvent, type CalendarBookingContact, type CalendarCareEntry, type CalendarCareLink, type CalendarClosure, type CalendarDayHours, type CalendarHistoryEntry, type CalendarPatient, type CalendarPhoneNumber, type CalendarSignDocument, type CalendarWaitingEntry } from './calendar.types';
+import { type CareDescriptionMode, type ColorAssociation, type CalendarBaseEvent, type CalendarBookingContact, type CalendarCareEntry, type CalendarCareLink, type CalendarClosure, type CalendarDayHours, type CalendarHistoryEntry, type CalendarPatient, type CalendarPhoneNumber, type CalendarSignDocument, type CalendarWaitingEntry, type PatientRef } from './calendar.types';
 export declare const STATUS_UI_KEY: Record<CalendarEventStatus, string>;
 export interface CalendarRow {
     event: CalendarEvent;
@@ -47,6 +47,11 @@ export interface PendingMove {
     revert?: () => void;
 }
 export declare function movesSilently(event: CalendarEvent): boolean;
+/** The reference for one patient id — the record when the host could
+ *  answer, and always the id itself. */
+export declare function patientRefById(id: string | number | null | undefined, data: CalendarData): PatientRef;
+/** The reference for the patient an appointment carries. */
+export declare function eventPatientRef(event: CalendarEvent, data: CalendarData): PatientRef;
 export declare function isPendingBooking(event: CalendarEvent): boolean;
 export declare function selectPendingBookings(rows: CalendarRow[]): CalendarRow[];
 /**
@@ -420,7 +425,11 @@ export declare function buildBacklog(args: {
 }, data: CalendarData): BacklogItem[];
 /** Per-type counts — the strip's segment badges. */
 export declare function backlogCounts(items: readonly BacklogItem[]): Record<BacklogType, number>;
-/** The patient behind a row (bookings have none — a typed name only). */
+/** The patient behind a row (bookings have none — a typed name only),
+ *  as the reference: `assigned` says whether anyone is booked at all,
+ *  which is what a "no patient" label may key on — never the record. */
+export declare function backlogPatientRef(item: BacklogItem, data: CalendarData): PatientRef;
+/** The record behind a queue row, when the host could load it. */
 export declare function backlogPatient(item: BacklogItem, data: CalendarData): CalendarPatient | undefined;
 /** The row's headline — patient name, the booker's typed name, or the
  *  free-text hold. */
@@ -448,9 +457,9 @@ export declare function waitingEntryInQuickView(entry: CalendarWaitingEntry, vie
 export declare function filterWaitingQuickView(items: readonly BacklogItem[], view: WaitingQuickView, data: CalendarData): BacklogItem[];
 /**
  * Process an online booking: the editor opens for THAT event with the
- * booker's typed details, a matching record pre-selected, and BOTH the
- * patient and the operator marked required — the two things the booking
- * needs before it leaves the queue.
+ * booker's typed details, a patient pre-selected — the id the booking
+ * already carries, or a typed-name match — and BOTH the patient and the
+ * operator marked required, the two things it needs to leave the queue.
  */
 export declare function processBookingPrefill(row: CalendarRow, data: CalendarData): EditorPrefill;
 /** Assign an operator: the editor opens for the event with the operator
@@ -621,6 +630,10 @@ export interface PrintSheetInput {
 /** A date-only start (all-day rows) is already a local day; anything
  *  else parses as the wall clock the fixtures and the editor write. */
 export declare function parseEventDate(value: string | Date): Date;
+/** The title privacy mode shows. TOTAL in the masked branch: a host
+ *  that supplies an EMPTY `privacyModeTitle` gets the bullets, never a
+ *  blank and never a fallback that would leak what we do or do not hold
+ *  on the one surface whose job is to say nothing. */
 export declare function maskedTitle(event: CalendarEvent, privacy: boolean): string;
 export declare function printRowOf(row: CalendarRow, privacy: boolean, data: CalendarData): PrintRow;
 export declare function byStart(a: PrintRow, b: PrintRow): number;

package/dist/patterns/calendar/calendar.sheets.d.ts

@@ -24,7 +24,7 @@
 import { type ReactNode } from 'react';
 import { type CalendarEvent } from '../../components/calendar';
 import { type NotesPanelNote, type NotesPanelProps, type NotesPanelSubmission } from '../../components/notes-panel';
-import { type ColorAssociation, type CalendarCarePlan, type CalendarAnamnesisAnswer, type CalendarOperatorGroup, type CalendarPatient, type CalendarWaitingEntry, type CalendarHistoryEntry, type CalendarSignChannel } from './calendar.types';
+import { type ColorAssociation, type CalendarCarePlan, type CalendarAnamnesisAnswer, type CalendarOperatorGroup, type CalendarPatient, type CalendarWaitingEntry, type CalendarHistoryEntry, type CalendarSignChannel, type PatientRef } from './calendar.types';
 import { type CalendarRow, type DisplaySettings, type EditorPrefill, type EditorDraft, type DraftSlot, type SlotPatch, type BacklogFilter, type BacklogItem, type WaitingEntryDraft, type CalendarFreeSlot, type PrintDaySection, type FindSlotsSeed, type AvailabilityContext } from './calendar.model';
 import { type EditorDraftExtras, type DeleteOptions } from './calendar-workspace.model';
 export declare function TaskDetailsPanel({ row, locale, }: {
@@ -206,9 +206,11 @@ export declare function AppointmentEditorPanel({ prefill, onSave, onDelete, onDu
 export declare function IndicatorChips({ event }: {
     event: CalendarEvent;
 }): import("react/jsx-runtime").JSX.Element | null;
-export declare function AppointmentIdentity({ row, patient, showAge, onOpenPatient, anamnesisAnswers, }: {
+export declare function AppointmentIdentity({ row, patientRef, showAge, onOpenPatient, anamnesisAnswers, }: {
     row: CalendarRow;
-    patient?: CalendarPatient;
+    /** Who this appointment is for: the id it carries and the record, when
+     *  the host could resolve it. */
+    patientRef: PatientRef;
     /** Append the platform popover's "(NN anni)" to the name (audit C15). */
     showAge?: boolean;
     /** Set = the name becomes the platform's patient-folder link. */
@@ -217,8 +219,7 @@ export declare function AppointmentIdentity({ row, patient, showAge, onOpenPatie
      *  details dialog lists them, the popover only counts (audit C16). */
     anamnesisAnswers?: readonly CalendarAnamnesisAnswer[];
 }): import("react/jsx-runtime").JSX.Element;
-export declare function SendReminderGroup({ patient, onWhatsApp, channels: allowed, }: {
-    patient: CalendarPatient;
+export declare function SendReminderGroup({ onWhatsApp, channels: allowed, }: {
     /** When set, the WhatsApp segment bridges to the legacy Snippets
      *  island instead of the demo-fake send. */
     onWhatsApp?: () => void;

package/dist/patterns/calendar/calendar.types.d.ts

@@ -30,25 +30,36 @@ export interface CalendarAnamnesisAnswer {
     answer?: string;
     interviewIso: string;
 }
+/**
+ * A patient as the HOST knows them. Only the identity — `id` and `name` —
+ * is required: a host whose appointment feed carries a patient id and a
+ * display name and nothing else supplies exactly those two, and every
+ * reader below treats each remaining field as "the host did not tell us".
+ *
+ * The rule for a reader: never render a row, chip or label that asserts a
+ * value for a field the host omitted — an empty fiscal code printed under
+ * a "Fiscal code" label is a claim about the record, not a blank. Omit the
+ * row; where every row of a section would go, omit the section.
+ */
 export interface CalendarPatient {
     id: string;
     name: string;
-    dobIso: string;
-    phone: string;
-    email: string;
+    dobIso?: string;
+    phone?: string;
+    email?: string;
     smsEnabled?: boolean;
     emailEnabled?: boolean;
-    city: string;
+    city?: string;
     /** Optional profile photo — Avatar falls back to the initials circle. */
     avatarSrc?: string;
-    sex: 'f' | 'm';
-    fiscalCode: string;
-    address: string;
-    province: string;
-    postalCode: string;
-    patientSinceIso: string;
-    lastVisitIso: string;
-    priceList: string;
+    sex?: 'f' | 'm';
+    fiscalCode?: string;
+    address?: string;
+    province?: string;
+    postalCode?: string;
+    patientSinceIso?: string;
+    lastVisitIso?: string;
+    priceList?: string;
     discountPct?: number;
     unpaidAmount?: number;
     allergies?: string;
@@ -390,8 +401,63 @@ export type CalendarHistoryEntry = {
     kind: 'deleted';
 });
 /** Every labelled phone number — the single `phone` is the mobile when a
- *  patient carries no explicit list (platform prints each label: number). */
+ *  patient carries no explicit list (platform prints each label: number).
+ *  A patient the host supplied without either has no numbers to print,
+ *  which is not the same as one labelled blank: the list comes back empty
+ *  and the caller omits the block. */
 export declare function patientPhones(patient: CalendarPatient): CalendarPhoneNumber[];
+/**
+ * A patient as the calendar can see them at one point: the id a row,
+ * an event or a waiting entry carries, plus the record if the host's
+ * `patientById` could answer.
+ */
+export interface PatientRef {
+    /** The id, as a string. `''` — and ONLY `''` — means nobody is booked. */
+    readonly id: string;
+    /** The record, when the host could resolve the id. */
+    readonly record?: CalendarPatient;
+    /** Someone is booked here, resolved or not. The existence test. */
+    readonly assigned: boolean;
+    /** Someone is booked and their record did not load — state A. */
+    readonly unresolved: boolean;
+}
+/** A patient id as a string, `''` when there is none. A host id of `0`
+ *  IS an id, so the test is `!= null` and never truthiness. */
+export declare function patientIdOf(id: string | number | null | undefined): string;
+/** Pair the id a row carries with whatever the host made of it. */
+export declare function patientRefOf(id: string | number | null | undefined, record: CalendarPatient | undefined): PatientRef;
+/** What to CALL this patient: the record's name, else the title the row
+ *  already carries, else the caller's localised "record not loaded".
+ *  Never blank — a blank name renders an initials-less avatar — and
+ *  never the "no patient assigned" of an unbooked slot. */
+export declare function patientRefName(ref: PatientRef, rowTitle: string | undefined, notLoadedLabel: string): string;
+/** Why a notify / signing channel is or is not usable for a patient. */
+export type PatientChannelState = 
+/** On file, and the patient takes messages there. */
+'ready'
+/** On file, and the patient opted this channel out. */
+ | 'optedOut'
+/** The record loaded and really carries nothing here — state C, the
+ *  only state in which "none on file" may be said. */
+ | 'none'
+/** We were not told: no record at all, or the record omits the field
+ *  — states A and B. Says nothing about what the practice holds. */
+ | 'unknown';
+/** The state of one channel for one patient reference. */
+export declare function patientChannelState(ref: PatientRef, channel: 'sms' | 'email'): PatientChannelState;
+/** A channel the kit can hand a destination to right now — the test for
+ *  seeding a checkbox ON, or for defaulting a sign mode to it. */
+export declare function channelReady(state: PatientChannelState): boolean;
+/** A channel the kit must leave OFFERED. `unknown` belongs here: the
+ *  host may well succeed on send, and disabling the control would claim
+ *  the practice holds nothing — a claim about a record we never saw. */
+export declare function channelOfferable(state: PatientChannelState): boolean;
+/** The reason a channel is not offered — `null` when it IS offered, so
+ *  a caller never has to invent a string for a state it cannot reach. */
+export declare function channelReasonKey(state: PatientChannelState, keys: {
+    optedOut: string;
+    none: string;
+}): string | null;
 /** Practice-level toggles the platform gates the editor and popover on. */
 export interface CalendarPracticeFeatures {
     /** `FIND_FREE_SLOTS_BY_CARE` — devices per care, the device line. */

package/dist/patterns/calendar/index.js

@@ -1,4 +1,4 @@
-import { C as s, a as r, b as E, D as P, c as t, S, V as A, W as C, d, i as o, m as D, r as i, u as n, e as W, f as _ } from "../../_chunks/calendar-workspace-CGuY4kmv.js";
+import { C as s, a as r, b as E, D as P, c as t, S, V as A, W as C, d, i as o, m as D, r as i, u as n, e as W, f as _ } from "../../_chunks/calendar-workspace-B87-QI8L.js";
 export {
   s as CALENDAR_PREFERENCE_KEYS,
   r as CalendarDataProvider,