@eka-care/medical-records-ui 1.0.3

package/dist/index.d.mts

@@ -0,0 +1,390 @@
+import * as react from 'react';
+import { ReactNode, MouseEvent } from 'react';
+import { SDKEnvironment, EditRecordRequest, CreateCaseRequest, UpdateCaseRequest } from '@eka-care/medical-records-ts-sdk';
+import * as zustand from 'zustand';
+
+type Environment = SDKEnvironment;
+interface DocumentTypeConfig {
+    id: string;
+    display_name: string;
+    hex?: string;
+    bg_hex?: string;
+    archive?: boolean;
+}
+interface SdkConfig {
+    environment?: Environment;
+    baseUrl?: string;
+    /** Extra headers (client-id, flavour, b-tid, …). */
+    defaultHeaders?: Record<string, string>;
+    onError?: (error: unknown) => void;
+    onUnauthorized?: () => Promise<string | undefined> | string | undefined;
+    accessToken?: string;
+    transport?: 'native' | 'bridge';
+    oid?: string;
+}
+
+interface SdkProviderProps {
+    config: SdkConfig;
+    bid?: string;
+    patientId?: string;
+    /**
+     * Document-type definitions from the host's onboarding config
+     * (`mr_document_type`). Drives the code → display-name labels shown across
+     * the feature; the SDK's static map is the fallback when a code is absent.
+     */
+    documentTypes?: DocumentTypeConfig[];
+    children: ReactNode;
+}
+declare function SdkProvider({ config, bid, patientId, documentTypes, children }: SdkProviderProps): react.JSX.Element;
+
+type DocumentTypeLabelResolver = (code: string) => string;
+
+interface RecordItemProps {
+    record: RecordItem;
+    selected: boolean;
+    selectionMode?: boolean;
+    thumbnailUrl?: string | null;
+    inContext?: boolean;
+    attachDisabled?: boolean;
+    selectDisabled?: boolean;
+    isUploading?: boolean;
+    isUploadFailed?: boolean;
+    isAnalysing?: boolean;
+    isSmart?: boolean;
+    dateDisplay: string;
+    onSelect: (id: string) => void;
+    onOpen: (id: string) => void;
+    onDelete: (id: string) => void;
+    onAddToContext: (id: string) => void;
+    onCopyNotes: (id: string, anchor?: {
+        x: number;
+        y: number;
+    }) => void;
+}
+interface RecordItem {
+    id: string;
+    patientId: string;
+    title: string;
+    typeCode: string;
+    type: string;
+    thumbnailUrl: string | null;
+    createdAtEpoch: number;
+    updatedAtEpoch: number;
+    tags: string[];
+    cases: string[];
+    syncState: 'uploading' | 'upload_success' | 'upload_failure' | null;
+    fileType: string | null;
+    isSmart: boolean;
+    isAnalysing: boolean;
+}
+interface UploadQueueItem {
+    id: string;
+    fileName: string;
+    mimeType: string;
+    sizeBytes: number;
+    progress: number;
+    status: 'pending' | 'uploading' | 'completed' | 'upload_failure';
+    documentId?: string;
+}
+interface CaseUiItem {
+    id: string;
+    name: string;
+    typeCode: string;
+    createdAtEpoch: number;
+    updatedAtEpoch: number;
+    occurredAtEpoch: number | null;
+}
+
+type RecordsStatus = 'idle' | 'loading' | 'stale' | 'fresh' | 'error';
+interface RecordsSlice {
+    byId: Record<string, RecordItem>;
+    ids: string[];
+    status: RecordsStatus;
+    error: string | null;
+    pendingIds: Set<string>;
+    setAll: (records: RecordItem[]) => void;
+    upsert: (record: RecordItem) => void;
+    remove: (id: string) => void;
+    markPending: (id: string) => void;
+    unmarkPending: (id: string) => void;
+    setStatus: (status: RecordsStatus) => void;
+    setError: (error: string | null) => void;
+}
+
+interface CasesSlice {
+    byId: Record<string, CaseUiItem>;
+    ids: string[];
+    status: RecordsStatus;
+    error: string | null;
+    setAll: (cases: CaseUiItem[]) => void;
+    upsert: (caseItem: CaseUiItem) => void;
+    remove: (id: string) => void;
+    setStatus: (status: RecordsStatus) => void;
+    setError: (error: string | null) => void;
+}
+
+interface UploadSlice {
+    queue: UploadQueueItem[];
+    add: (item: UploadQueueItem) => void;
+    updateProgress: (id: string, progress: number) => void;
+    markCompleted: (id: string, documentId: string) => void;
+    markFailed: (id: string) => void;
+    remove: (id: string) => void;
+}
+
+interface SelectionSlice {
+    recordIds: Set<string>;
+    openDetailId: string | null;
+    toggleRecord: (id: string, max?: number) => void;
+    clearSelection: () => void;
+    openDetail: (id: string | null) => void;
+}
+
+type DatePreset = 'anytime' | 'last7' | 'last30' | 'last3m' | 'custom';
+interface PopoverFilters {
+    documentDateFrom: number | null;
+    documentDateTo: number | null;
+    uploadDateFrom: number | null;
+    uploadDateTo: number | null;
+    documentDatePreset: DatePreset;
+    uploadDatePreset: DatePreset;
+    tags: string[];
+}
+interface FiltersSlice {
+    type: string | null;
+    search: string;
+    documentDateFrom: number | null;
+    documentDateTo: number | null;
+    uploadDateFrom: number | null;
+    uploadDateTo: number | null;
+    documentDatePreset: DatePreset;
+    uploadDatePreset: DatePreset;
+    tags: string[];
+    sortBy: 'date' | 'name';
+    sortDir: 'asc' | 'desc';
+    setType: (type: string | null) => void;
+    setSearch: (q: string) => void;
+    applyPopoverFilters: (filters: PopoverFilters) => void;
+    setSortBy: (by: FiltersSlice['sortBy']) => void;
+    setSortDir: (dir: FiltersSlice['sortDir']) => void;
+    clearPopoverFilters: () => void;
+    reset: () => void;
+}
+
+type SyncStatus = 'online' | 'offline' | 'syncing';
+interface SyncSlice {
+    status: SyncStatus;
+    pendingSyncCount: number;
+    setStatus: (status: SyncStatus) => void;
+    incrementPending: () => void;
+    decrementPending: () => void;
+}
+
+type DetailStatus = 'idle' | 'loading' | 'loaded' | 'error';
+interface RecordDetail {
+    status: DetailStatus;
+    isSmart: boolean;
+    /** Verified smart-report fields as `name: value` lines, ready to copy/paste. */
+    smartText: string;
+}
+interface DetailsSlice {
+    byId: Record<string, RecordDetail>;
+    setDetailLoading: (id: string) => void;
+    setDetail: (id: string, detail: {
+        isSmart: boolean;
+        smartText: string;
+    }) => void;
+    setDetailError: (id: string) => void;
+}
+
+/** Composite state for a single patient's store. */
+interface PatientState {
+    bid: string;
+    patientId: string;
+    records: RecordsSlice;
+    cases: CasesSlice;
+    details: DetailsSlice;
+    uploadQueue: UploadSlice;
+    selection: SelectionSlice;
+    filters: FiltersSlice;
+    sync: SyncSlice;
+    /** Disposal hook fired when SdkProvider unmounts or the patient changes. */
+    __cleanup: () => void;
+}
+
+/**
+ * Builds one Zustand store per patient. `subscribeWithSelector` is required so
+ * per-slice selectors re-render only on the state they read.
+ */
+declare function createPatientStore(bid: string, patientId: string): Omit<zustand.StoreApi<PatientState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: PatientState, previousSelectedState: PatientState) => void): () => void;
+        <U>(selector: (state: PatientState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+type PatientStore = ReturnType<typeof createPatientStore>;
+
+interface SdkContextValue {
+    bid: string;
+    patientId: string;
+    store: PatientStore;
+    ready: boolean;
+    labelOf: DocumentTypeLabelResolver;
+    documentTypes: DocumentTypeConfig[];
+}
+
+declare function useSdk(): SdkContextValue;
+
+/** True now that the Core SDK package is installed and wired in. */
+declare const CORE_SDK_AVAILABLE = true;
+/** Clear cached DB data for the bid then drop the client reference. */
+declare function logoutMedicalRecords(bid?: string): Promise<void>;
+
+interface RecordsViewProps {
+    className?: string;
+    onUpload?: () => void;
+    allowUpload?: boolean;
+    onCopyToNote?: (text: string, anchor?: {
+        x: number;
+        y: number;
+    }) => void | Promise<void>;
+    attachedIds?: string[];
+    onAttachManyToContext?: (records: Array<{
+        documentId: string;
+        name: string;
+    }>) => void | Promise<void>;
+    onRemoveAttachment?: (documentId: string) => void | Promise<void>;
+    onToast?: (message: string, type?: 'error' | 'success') => void;
+}
+declare function RecordsView({ className, onUpload, allowUpload, onCopyToNote, attachedIds, onAttachManyToContext, onRemoveAttachment, onToast, }: RecordsViewProps): react.JSX.Element;
+
+interface RecordsConnectionActions {
+    refresh: () => Promise<void>;
+    /** Unix epoch ms of the last successful server refresh, or null before first call. */
+    sourceRefreshedAt: number | null;
+    editRecord: (documentId: string, data: EditRecordRequest) => Promise<void>;
+    deleteRecord: (documentId: string) => Promise<void>;
+}
+declare function useRecordsConnection(): RecordsConnectionActions;
+
+interface CasesConnectionActions {
+    refresh: () => Promise<void>;
+    createCase: (data: Omit<CreateCaseRequest, 'id'> & {
+        id?: string;
+    }) => Promise<string>;
+    updateCase: (caseId: string, data: UpdateCaseRequest) => Promise<void>;
+    deleteCase: (caseId: string) => Promise<void>;
+}
+/**
+ * Loads cases for the current patient — but only when `enabled` (the Care
+ * Context tab is active), so the Date tab never triggers a cases fetch. Loads
+ * once per patient (cache-then-network via onStale); a `cases:changed`
+ * subscription keeps the store live while enabled.
+ */
+declare function useCasesConnection(enabled?: boolean): CasesConnectionActions;
+
+interface UploadFileInput {
+    file: File;
+    documentType: string;
+    documentDateMs: number;
+    caseIds?: string[];
+    tags?: string[];
+}
+interface UploadConnectionActions {
+    upload: (items: UploadFileInput[]) => Promise<void>;
+}
+declare function useUploadConnection(): UploadConnectionActions;
+
+/**
+ * Tear down UI SDK state: drop the Core SDK client reference. The active patient
+ * store is owned by SdkProvider and disposed on unmount, so there's nothing else
+ * to clear here. (The Core SDK holds no persistent worker to shut down — auth
+ * lives in the host app.)
+ */
+declare function useLogout(): () => void;
+
+declare function useRecordById(id: string): RecordItem | undefined;
+declare function useRecordIdRange(start: number, end: number): string[];
+declare function useRecordsCount(): number;
+declare function useRecordsStatus(): RecordsStatus;
+declare function useThumbnailUrl(id: string): string | null;
+declare function useIsSelected(id: string): boolean;
+declare function useCaseById(id: string): CaseUiItem | undefined;
+declare function useCaseIds(): string[];
+declare function useCasesStatus(): RecordsStatus;
+declare function useFilteredRecordIds(): string[];
+
+interface SkeletonProps {
+    variant: 'card' | 'list-item' | 'text' | 'circle';
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+}
+declare function Skeleton({ variant, width, height, className }: SkeletonProps): react.JSX.Element;
+
+interface BadgeProps {
+    variant: 'smart' | 'analysing' | 'uploading' | 'upload_failure';
+    label: string;
+}
+declare const Badge: react.NamedExoticComponent<BadgeProps>;
+
+interface TagChipProps {
+    label: string;
+    removable?: boolean;
+    onRemove?: () => void;
+    onClick?: (e: MouseEvent<HTMLSpanElement>) => void;
+}
+declare const TagChip: react.NamedExoticComponent<TagChipProps>;
+
+interface IconButtonProps {
+    icon: ReactNode;
+    'aria-label': string;
+    title?: string;
+    variant?: 'default' | 'primary' | 'solid' | 'ghost' | 'destructive';
+    disabled?: boolean;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+}
+declare const IconButton: react.NamedExoticComponent<IconButtonProps>;
+
+interface ThumbnailProps {
+    url: string | null;
+    size?: number;
+    alt?: string;
+}
+declare const Thumbnail: react.NamedExoticComponent<ThumbnailProps>;
+
+interface FilterChipProps {
+    id: string;
+    label: string;
+    count?: number;
+    active: boolean;
+    onSelect: (id: string) => void;
+}
+declare const FilterChip: react.NamedExoticComponent<FilterChipProps>;
+
+interface SidebarItemProps {
+    id: string;
+    dayNumber: string;
+    weekday: string;
+    countLabel: string;
+    summary: string;
+    selected: boolean;
+    onSelect: (id: string) => void;
+}
+declare const SidebarItem: react.NamedExoticComponent<SidebarItemProps>;
+
+interface RecordCardProps extends RecordItemProps {
+    dense?: boolean;
+}
+declare const RecordCard: react.NamedExoticComponent<RecordCardProps>;
+
+declare const RecordRow: react.NamedExoticComponent<RecordItemProps>;
+
+declare function EmptyRecordsIcon({ size }: {
+    size?: number;
+}): react.JSX.Element;
+
+export { Badge, CORE_SDK_AVAILABLE, type CaseUiItem, type DocumentTypeConfig, EmptyRecordsIcon, type Environment, FilterChip, IconButton, RecordCard, type RecordItem, RecordRow, RecordsView, type RecordsViewProps, type SdkConfig, SdkProvider, type SdkProviderProps, SidebarItem, Skeleton, TagChip, Thumbnail, logoutMedicalRecords, useCaseById, useCaseIds, useCasesConnection, useCasesStatus, useFilteredRecordIds, useIsSelected, useLogout, useRecordById, useRecordIdRange, useRecordsConnection, useRecordsCount, useRecordsStatus, useSdk, useThumbnailUrl, useUploadConnection };