@omersx/bemms 0.0.0-stage → 1.0.0

package/src/lib/utils/export.ts

@@ -0,0 +1,45 @@
+// Generate CSV with BOM for Excel compatibility
+export function generateCSV(data: Record<string, unknown>[], columns: { key: string; header: string }[]): string {
+  const BOM = '\uFEFF';
+  if (!data || data.length === 0) {
+    return BOM + columns.map(c => `"${c.header.replace(/"/g, '""')}"`).join(',');
+  }
+
+  const headerRow = columns.map(c => `"${c.header.replace(/"/g, '""')}"`).join(',');
+  const rows = data.map(row => 
+    columns.map(c => {
+      let val = row[c.key];
+      if (val === null || val === undefined) val = '';
+      return `"${String(val).replace(/"/g, '""')}"`;
+    }).join(',')
+  );
+
+  return BOM + [headerRow, ...rows].join('\n');
+}
+
+// Format report metadata for transparency header
+export function formatReportMetadata(params: {
+  reportType: string;
+  filters: Record<string, unknown>;
+  dateRange?: { start?: string; end?: string };
+  timezone: string;
+  generatedAt: Date;
+  generatedBy: string;
+}): string {
+  const lines = [
+    `Report Type: ${params.reportType}`,
+    `Generated At: ${params.generatedAt.toISOString()} (${params.timezone})`,
+    `Generated By: ${params.generatedBy}`,
+  ];
+  
+  if (params.dateRange?.start) lines.push(`Date Range Start: ${params.dateRange.start}`);
+  if (params.dateRange?.end) lines.push(`Date Range End: ${params.dateRange.end}`);
+  
+  const filterEntries = Object.entries(params.filters).filter(([k, v]) => v !== undefined && k !== 'page' && k !== 'pageSize' && k !== 'startDate' && k !== 'endDate' && k !== 'timezone');
+  if (filterEntries.length > 0) {
+    lines.push(`Filters: ${JSON.stringify(Object.fromEntries(filterEntries))}`);
+  }
+  
+  return lines.map(line => `# ${line}`).join('\n') + '\n\n';
+}
+

package/src/lib/utils/nav-badge.ts

@@ -0,0 +1,225 @@
+import { cva, type VariantProps } from 'class-variance-authority';
+
+export type NavBadgeType = 'count' | 'dot' | 'status';
+export type NavBadgePosition = 'trailing' | 'icon-corner' | 'inline';
+
+export const navBadgeVariants = cva(
+  'transition-all duration-200 select-none font-medium',
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground',
+        primary: 'bg-primary text-primary-foreground',
+        secondary: 'bg-secondary text-secondary-foreground',
+        success: 'bg-emerald-600 text-white dark:bg-emerald-500',
+        warning: 'bg-amber-500 text-white dark:bg-amber-600',
+        danger: 'bg-destructive text-destructive-foreground',
+        destructive: 'bg-destructive text-destructive-foreground',
+        outline: 'border border-border bg-background text-foreground',
+      },
+      position: {
+        trailing: 'ml-auto shrink-0',
+        inline: 'shrink-0',
+        'icon-corner': 'absolute -top-1 -right-1 z-10 pointer-events-none ring-2 ring-card',
+      },
+      type: {
+        count: 'inline-flex items-center justify-center font-semibold text-center',
+        status: 'inline-flex items-center justify-center font-medium uppercase tracking-wider',
+        dot: 'rounded-full inline-block shrink-0',
+      },
+    },
+    compoundVariants: [
+      // Count badge sizing
+      {
+        type: 'count',
+        position: 'trailing',
+        className: 'min-w-[20px] h-5 px-1.5 rounded-full text-[11px] leading-none',
+      },
+      {
+        type: 'count',
+        position: 'inline',
+        className: 'min-w-[18px] h-4.5 px-1.5 rounded-full text-[10px] leading-none',
+      },
+      {
+        type: 'count',
+        position: 'icon-corner',
+        className: 'min-w-[18px] h-4.5 px-1 rounded-full text-[10px] leading-none shadow-xs font-bold',
+      },
+      // Status badge sizing
+      {
+        type: 'status',
+        position: 'trailing',
+        className: 'px-2 py-0.5 rounded-md text-[10px] max-w-[80px] truncate',
+      },
+      {
+        type: 'status',
+        position: 'inline',
+        className: 'px-1.5 py-0.5 rounded text-[9px] max-w-[70px] truncate',
+      },
+      {
+        type: 'status',
+        position: 'icon-corner',
+        className: 'px-1 py-0.5 rounded text-[8px] leading-none max-w-[50px] truncate',
+      },
+      // Dot badge sizing
+      {
+        type: 'dot',
+        position: 'icon-corner',
+        className: 'w-2.5 h-2.5',
+      },
+      {
+        type: 'dot',
+        position: 'trailing',
+        className: 'w-2 h-2 ml-auto',
+      },
+      {
+        type: 'dot',
+        position: 'inline',
+        className: 'w-2 h-2',
+      },
+    ],
+    defaultVariants: {
+      variant: 'default',
+      position: 'trailing',
+      type: 'count',
+    },
+  }
+);
+
+export type NavBadgeVariant = NonNullable<VariantProps<typeof navBadgeVariants>['variant']>;
+
+export interface NavBadgeConfig {
+  /**
+   * Whether the badge is enabled and visible.
+   * Default: true
+   */
+  enabled?: boolean;
+  /**
+   * Badge type:
+   * - 'count': numerical count with maxCount formatting (e.g. 5, 99+)
+   * - 'dot': compact circular indicator
+   * - 'status': short text label (e.g. "NEW", "DUE")
+   * Default: 'count'
+   */
+  type?: NavBadgeType;
+  /**
+   * Numerical count or text value for status badges.
+   */
+  value?: number | string | null;
+  /**
+   * Visual variant/color theme.
+   * Default: 'default'
+   */
+  variant?: NavBadgeVariant;
+  /**
+   * Placement relative to the navigation item:
+   * - 'trailing': at the right end of the item (ideal for expanded sidebars)
+   * - 'icon-corner': anchored to the top-right of the icon (ideal for collapsed sidebars & mobile nav)
+   * - 'inline': alongside the label
+   * Default: 'trailing'
+   */
+  position?: NavBadgePosition;
+  /**
+   * Maximum count before formatting with "+" (e.g. 99 -> "99+").
+   * Default: 99
+   */
+  maxCount?: number;
+  /**
+   * Whether to hide count badge when value is 0.
+   * Default: true
+   */
+  hideWhenZero?: boolean;
+  /**
+   * Whether to animate with a pulse effect (great for urgent alerts or activity dots).
+   * Default: false
+   */
+  pulse?: boolean;
+  /**
+   * Accessible description for screen readers (e.g. "5 unread notifications").
+   */
+  ariaLabel?: string;
+  /**
+   * Additional custom CSS classes.
+   */
+  className?: string;
+}
+
+export interface FormattedNavBadge {
+  visible: boolean;
+  display: string;
+  isDot: boolean;
+  accessibleDescription: string;
+}
+
+/**
+ * Format and calculate visibility of badge data according to badge type and configuration.
+ */
+export function formatNavBadge(config: NavBadgeConfig): FormattedNavBadge {
+  const {
+    enabled = true,
+    type = 'count',
+    value,
+    maxCount = 99,
+    hideWhenZero = true,
+    ariaLabel,
+  } = config;
+
+  if (!enabled) {
+    return { visible: false, display: '', isDot: false, accessibleDescription: '' };
+  }
+
+  if (type === 'dot') {
+    if (typeof value === 'number' && value === 0 && hideWhenZero) {
+      return { visible: false, display: '', isDot: true, accessibleDescription: '' };
+    }
+    return {
+      visible: true,
+      display: '',
+      isDot: true,
+      accessibleDescription: ariaLabel || 'New activity indicator',
+    };
+  }
+
+  if (type === 'status') {
+    if (!value && value !== 0) {
+      return { visible: false, display: '', isDot: false, accessibleDescription: '' };
+    }
+    const str = String(value);
+    return {
+      visible: true,
+      display: str,
+      isDot: false,
+      accessibleDescription: ariaLabel || `Status: ${str}`,
+    };
+  }
+
+  // Count type
+  const numValue = typeof value === 'number' ? value : Number(value);
+  if (isNaN(numValue)) {
+    if (value === null || value === undefined || value === '') {
+      return { visible: false, display: '', isDot: false, accessibleDescription: '' };
+    }
+    const str = String(value);
+    return {
+      visible: true,
+      display: str,
+      isDot: false,
+      accessibleDescription: ariaLabel || `${str} items`,
+    };
+  }
+
+  if (numValue === 0 && hideWhenZero) {
+    return { visible: false, display: '', isDot: false, accessibleDescription: '' };
+  }
+
+  const display = numValue > maxCount ? `${maxCount}+` : String(numValue);
+  const accessibleDescription =
+    ariaLabel || (numValue > maxCount ? `More than ${maxCount} items` : `${numValue} items`);
+
+  return {
+    visible: true,
+    display,
+    isDot: false,
+    accessibleDescription,
+  };
+}

package/src/lib/utils/sound.ts

@@ -0,0 +1,152 @@
+/**
+ * BEMMS Sound Utilities
+ *
+ * Uses the Web Audio API to synthesize sounds programmatically.
+ * No external audio files needed — works on all modern browsers and native devices.
+ *
+ * Web Audio API is supported on iOS Safari, Android Chrome, and all desktop browsers.
+ * On mobile, sounds require a prior user gesture (tap) to unlock the AudioContext.
+ */
+
+let audioContext: AudioContext | null = null;
+
+/**
+ * Get or create the shared AudioContext.
+ * Must be called after a user gesture on mobile to unlock audio.
+ */
+function getAudioContext(): AudioContext | null {
+  if (typeof window === 'undefined') return null;
+
+  if (!audioContext) {
+    const AudioCtx =
+      window.AudioContext || (window as unknown as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
+    if (!AudioCtx) return null;
+    audioContext = new AudioCtx();
+  }
+
+  // Resume if suspended (required on mobile after tab switch / background)
+  if (audioContext.state === 'suspended') {
+    audioContext.resume().catch(() => {});
+  }
+
+  return audioContext;
+}
+
+// ── QR Scan Beep ─────────────────────────────────────────────────────────────────
+
+/**
+ * Play a short, clear "beep" to indicate a successful QR scan.
+ * Two-tone chirp that feels satisfying and professional on mobile devices.
+ */
+export function playQrBeep(): void {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+
+  const now = ctx.currentTime;
+
+  // --- Tone 1: rising chirp ---
+  const osc1 = ctx.createOscillator();
+  const gain1 = ctx.createGain();
+  osc1.type = 'sine';
+  osc1.frequency.setValueAtTime(1200, now);
+  osc1.frequency.linearRampToValueAtTime(1800, now + 0.08);
+  gain1.gain.setValueAtTime(0.35, now);
+  gain1.gain.exponentialRampToValueAtTime(0.01, now + 0.12);
+  osc1.connect(gain1);
+  gain1.connect(ctx.destination);
+  osc1.start(now);
+  osc1.stop(now + 0.12);
+
+  // --- Tone 2: confirmation note ---
+  const osc2 = ctx.createOscillator();
+  const gain2 = ctx.createGain();
+  osc2.type = 'sine';
+  osc2.frequency.setValueAtTime(1800, now + 0.1);
+  gain2.gain.setValueAtTime(0, now + 0.1);
+  gain2.gain.linearRampToValueAtTime(0.35, now + 0.12);
+  gain2.gain.exponentialRampToValueAtTime(0.01, now + 0.3);
+  osc2.connect(gain2);
+  gain2.connect(ctx.destination);
+  osc2.start(now + 0.1);
+  osc2.stop(now + 0.3);
+}
+
+// ── Notification Sound ───────────────────────────────────────────────────────────
+
+/**
+ * Play a pleasant notification chime for incoming alerts (new ticket, status change, etc.).
+ * Three ascending tones — distinct from the QR beep, gentle but attention-grabbing.
+ */
+export function playNotificationSound(): void {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+
+  const now = ctx.currentTime;
+
+  const tones = [
+    { freq: 660, start: 0, duration: 0.15 },      // E5
+    { freq: 880, start: 0.15, duration: 0.15 },    // A5
+    { freq: 1100, start: 0.30, duration: 0.25 },   // ~C#6
+  ];
+
+  tones.forEach(({ freq, start, duration }) => {
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.type = 'sine';
+    osc.frequency.setValueAtTime(freq, now + start);
+    gain.gain.setValueAtTime(0, now + start);
+    gain.gain.linearRampToValueAtTime(0.25, now + start + 0.02);
+    gain.gain.exponentialRampToValueAtTime(0.01, now + start + duration);
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    osc.start(now + start);
+    osc.stop(now + start + duration);
+  });
+}
+
+/**
+ * Play an urgent/critical notification sound — louder and more insistent.
+ * Used for critical priority tickets (patient care affected).
+ */
+export function playUrgentNotificationSound(): void {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+
+  const now = ctx.currentTime;
+
+  // Rapid two-pulse alarm tone
+  for (let i = 0; i < 2; i++) {
+    const offset = i * 0.3;
+
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.type = 'square';
+    osc.frequency.setValueAtTime(880, now + offset);
+    osc.frequency.linearRampToValueAtTime(1320, now + offset + 0.1);
+    gain.gain.setValueAtTime(0.2, now + offset);
+    gain.gain.exponentialRampToValueAtTime(0.01, now + offset + 0.2);
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    osc.start(now + offset);
+    osc.stop(now + offset + 0.2);
+  }
+}
+
+// ── Unlock Audio on First User Gesture ───────────────────────────────────────────
+
+/**
+ * Call this once on a user interaction (tap/click) to unlock audio on mobile devices.
+ * After this, sounds can play without further user gestures.
+ * Plays a silent buffer to unlock the AudioContext.
+ */
+export function unlockAudio(): void {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+
+  // Create and play a silent buffer to unlock
+  const buffer = ctx.createBuffer(1, 1, ctx.sampleRate);
+  const source = ctx.createBufferSource();
+  source.buffer = buffer;
+  source.connect(ctx.destination);
+  source.start(0);
+}

package/src/lib/utils/staff-status.ts

@@ -0,0 +1,115 @@
+/**
+ * Staff-facing plain-language status translations.
+ * Department staff (doctors/nurses) see these instead of internal codes.
+ */
+
+export interface StaffStatusInfo {
+  label: string;
+  color: 'blue' | 'indigo' | 'amber' | 'red' | 'green' | 'gray';
+  icon: string; // emoji
+  description: string;
+}
+
+const STAFF_STATUS_MAP: Record<string, StaffStatusInfo> = {
+  new: {
+    label: 'Submitted',
+    color: 'blue',
+    icon: '📝',
+    description: 'Your report has been submitted to Biomedical Engineering.',
+  },
+  acknowledged: {
+    label: 'Reviewed',
+    color: 'blue',
+    icon: '✓',
+    description: 'Your report has been reviewed by the biomedical team.',
+  },
+  in_triage: {
+    label: 'Being reviewed',
+    color: 'blue',
+    icon: '🔍',
+    description: 'The biomedical team is reviewing your report.',
+  },
+  assigned: {
+    label: 'Assigned to Engineering',
+    color: 'indigo',
+    icon: '👤',
+    description: 'An engineer has been assigned to work on this.',
+  },
+  in_progress: {
+    label: 'Being repaired',
+    color: 'amber',
+    icon: '🔧',
+    description: 'The engineer is actively working on this device.',
+  },
+  waiting_parts_vendor: {
+    label: 'Waiting for parts',
+    color: 'amber',
+    icon: '📦',
+    description: 'Repair is paused until replacement parts arrive.',
+  },
+  waiting_requester: {
+    label: 'Response requested',
+    color: 'red',
+    icon: '💬',
+    description: 'The biomedical team needs more information from you.',
+  },
+  resolved: {
+    label: 'Resolved',
+    color: 'green',
+    icon: '✅',
+    description: 'The issue has been fixed.',
+  },
+  closed: {
+    label: 'Closed',
+    color: 'gray',
+    icon: '✓',
+    description: 'This ticket is closed.',
+  },
+  cancelled: {
+    label: 'Cancelled',
+    color: 'gray',
+    icon: '—',
+    description: 'This ticket was cancelled.',
+  },
+  reopened: {
+    label: 'Reopened',
+    color: 'amber',
+    icon: '🔄',
+    description: 'This ticket has been reopened — work resumed.',
+  },
+};
+
+export function getStaffStatus(statusCode: string): StaffStatusInfo {
+  return STAFF_STATUS_MAP[statusCode] || {
+    label: statusCode.replace(/_/g, ' '),
+    color: 'gray' as const,
+    icon: '•',
+    description: '',
+  };
+}
+
+const STAFF_STATUS_STYLES: Record<string, { bg: string; text: string; border: string }> = {
+  blue: { bg: 'bg-blue-100 dark:bg-blue-950', text: 'text-blue-800 dark:text-blue-200', border: 'border-blue-200 dark:border-blue-800' },
+  indigo: { bg: 'bg-indigo-100 dark:bg-indigo-950', text: 'text-indigo-800 dark:text-indigo-200', border: 'border-indigo-200 dark:border-indigo-800' },
+  amber: { bg: 'bg-amber-100 dark:bg-amber-950', text: 'text-amber-800 dark:text-amber-200', border: 'border-amber-200 dark:border-amber-800' },
+  red: { bg: 'bg-red-100 dark:bg-red-950', text: 'text-red-800 dark:text-red-200', border: 'border-red-200 dark:border-red-800' },
+  green: { bg: 'bg-green-100 dark:bg-green-950', text: 'text-green-800 dark:text-green-200', border: 'border-green-200 dark:border-green-800' },
+  gray: { bg: 'bg-gray-100 dark:bg-gray-900', text: 'text-gray-600 dark:text-gray-400', border: 'border-gray-200 dark:border-gray-800' },
+};
+
+export function getStaffStatusStyle(statusCode: string) {
+  const info = getStaffStatus(statusCode);
+  return STAFF_STATUS_STYLES[info.color] || STAFF_STATUS_STYLES.gray;
+}
+
+/**
+ * Check if the given roles array represents a department staff user
+ * (STAFF or DEPT_MGR without any BME or admin roles).
+ */
+export function isStaffOnly(roles: string[]): boolean {
+  const staffRoles = ['STAFF', 'DEPT_MGR'];
+  const elevatedRoles = ['SYS_ADMIN', 'ORG_ADMIN', 'HOSP_ADMIN', 'BIOMED_MGR', 'BIOMED_ENG', 'BIOMED_TECH', 'AUDITOR'];
+  const hasStaff = roles.some(r => staffRoles.includes(r));
+  const hasElevated = roles.some(r => elevatedRoles.includes(r));
+  return hasStaff && !hasElevated;
+}

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/lib/validators/__tests__/auth.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import { loginSchema, registerSchema, changePasswordSchema, passwordResetSchema } from '../auth';
+
+describe('loginSchema', () => {
+  it('accepts valid email and password', () => {
+    const result = loginSchema.safeParse({
+      email: 'user@example.com',
+      password: 'password123',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts simple username like admin', () => {
+    const result = loginSchema.safeParse({
+      email: 'admin',
+      password: 'admin123',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects empty username/email', () => {
+    const result = loginSchema.safeParse({
+      email: '',
+      password: 'admin123',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects password shorter than 6 characters', () => {
+    const result = loginSchema.safeParse({
+      email: 'admin',
+      password: '12345',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing fields', () => {
+    const result = loginSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('registerSchema', () => {
+  it('accepts valid registration data', () => {
+    const result = registerSchema.safeParse({
+      email: 'user@example.com',
+      password: 'password123',
+      fullName: 'John Doe',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('requires fullName with min 2 characters', () => {
+    const result = registerSchema.safeParse({
+      email: 'user@example.com',
+      password: 'password123',
+      fullName: 'J',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('allows optional phone and jobTitle', () => {
+    const result = registerSchema.safeParse({
+      email: 'user@example.com',
+      password: 'password123',
+      fullName: 'John Doe',
+      phone: '+1234567890',
+      jobTitle: 'Engineer',
+    });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('changePasswordSchema', () => {
+  it('accepts valid password with all requirements', () => {
+    const result = changePasswordSchema.safeParse({
+      currentPassword: 'oldPassword',
+      newPassword: 'NewP@ss1',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects password without uppercase', () => {
+    const result = changePasswordSchema.safeParse({
+      currentPassword: 'oldPassword',
+      newPassword: 'newp@ss1',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects password without lowercase', () => {
+    const result = changePasswordSchema.safeParse({
+      currentPassword: 'oldPassword',
+      newPassword: 'NEWP@SS1',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects password without number', () => {
+    const result = changePasswordSchema.safeParse({
+      currentPassword: 'oldPassword',
+      newPassword: 'NewP@ssw',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects password without special character', () => {
+    const result = changePasswordSchema.safeParse({
+      currentPassword: 'oldPassword',
+      newPassword: 'NewPass1s',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('passwordResetSchema', () => {
+  it('accepts valid email', () => {
+    const result = passwordResetSchema.safeParse({ email: 'user@example.com' });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid email', () => {
+    const result = passwordResetSchema.safeParse({ email: 'bad' });
+    expect(result.success).toBe(false);
+  });
+});
+