hazo_chat 2.0.10 → 2.0.11

package/README.md

@@ -344,6 +344,7 @@ hazo_chat requires these API endpoints:
 |----------|--------|-------------|
 | `/api/hazo_chat/messages` | GET | Fetch chat messages |
 | `/api/hazo_chat/messages` | POST | Send a new message |
+| `/api/hazo_chat/unread_count` | GET | Get unread message counts by reference_id (optional) |
 | `/api/hazo_auth/me` | GET | Get current authenticated user |
 | `/api/hazo_auth/profiles` | POST | Fetch user profiles by IDs |
 
@@ -372,6 +373,157 @@ export { GET, POST };
 
 If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST.md](./SETUP_CHECKLIST.md) for detailed examples.
 
+## Library Functions
+
+hazo_chat provides server-side library functions that can be used in API routes, server components, or server actions.
+
+### hazo_chat_get_unread_count
+
+Get unread message counts grouped by reference_id for a receiver user.
+
+**Purpose:** Returns an array of reference IDs with the count of unread messages (where `read_at` is `null`) for a given receiver user ID. Useful for displaying unread message badges or notifications.
+
+**Usage:**
+
+```typescript
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+// Create the function using the factory
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+// Use the function
+const unreadCounts = await hazo_chat_get_unread_count('receiver-user-id-123');
+// Returns: [
+//   { reference_id: 'ref-1', count: 5 },
+//   { reference_id: 'ref-2', count: 3 },
+//   { reference_id: '', count: 1 }  // Empty reference_id for general messages
+// ]
+```
+
+**Return Type:**
+
+```typescript
+interface UnreadCountResult {
+  reference_id: string;  // The reference ID (empty string for messages without reference)
+  count: number;         // Number of unread messages for this reference
+}
+```
+
+**Function Behavior:**
+- Only counts messages where `read_at` is `null` and `deleted_at` is `null`
+- Groups results by `reference_id`
+- Sorts results by count (descending - most unread first)
+- Returns empty array if no unread messages found
+- Returns empty array on errors (doesn't throw)
+
+**Example: API Route Implementation**
+
+```typescript
+// app/api/hazo_chat/unread_count/route.ts
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+import { NextRequest, NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const receiver_user_id = searchParams.get('receiver_user_id');
+
+    if (!receiver_user_id) {
+      return NextResponse.json(
+        { 
+          success: false, 
+          error: 'receiver_user_id is required',
+          unread_counts: []
+        },
+        { status: 400 }
+      );
+    }
+
+    const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+
+    return NextResponse.json({
+      success: true,
+      receiver_user_id,
+      unread_counts,
+      total_references: unread_counts.length,
+      total_unread: unread_counts.reduce((sum, item) => sum + item.count, 0)
+    });
+  } catch (error) {
+    const error_message = error instanceof Error ? error.message : 'Unknown error';
+    return NextResponse.json(
+      { 
+        success: false, 
+        error: error_message,
+        unread_counts: []
+      },
+      { status: 500 }
+    );
+  }
+}
+```
+
+**Example: Server Component Usage**
+
+```typescript
+// app/chat/unread-badge.tsx
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export default async function UnreadBadge({ 
+  receiver_user_id 
+}: { 
+  receiver_user_id: string 
+}) {
+  const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+  const total_unread = unread_counts.reduce((sum, item) => sum + item.count, 0);
+
+  if (total_unread === 0) return null;
+
+  return (
+    <div className="flex gap-2">
+      {unread_counts.map((item) => (
+        <div key={item.reference_id || 'general'}>
+          <span>{item.reference_id || 'General'}: {item.count}</span>
+        </div>
+      ))}
+      <span>Total: {total_unread}</span>
+    </div>
+  );
+}
+```
+
+**Example: Server Action Usage**
+
+```typescript
+// app/actions/chat.ts
+'use server';
+
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function getUnreadCounts(receiver_user_id: string) {
+  return await hazo_chat_get_unread_count(receiver_user_id);
+}
+```
+
 ## Props Reference
 
 ### HazoChatProps
@@ -390,6 +542,9 @@ If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST
 | `title` | `string` | ❌ | - | Chat header title |
 | `subtitle` | `string` | ❌ | - | Chat header subtitle |
 | `on_close` | `() => void` | ❌ | - | Close button callback |
+| `show_sidebar_toggle` | `boolean` | ❌ | `false` | Show sidebar toggle button (hamburger menu) |
+| `show_delete_button` | `boolean` | ❌ | `true` | Show delete button on chat bubbles |
+| `bubble_radius` | `'default' \| 'full'` | ❌ | `'default'` | Bubble border radius style: `'default'` (rounded with tail) or `'full'` (fully round) |
 | `className` | `string` | ❌ | - | Additional CSS classes |
 
 ### Example with All Props
@@ -413,6 +568,186 @@ If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST
 />
 ```
 
+## Customization
+
+hazo_chat provides props to customize component appearance and behavior without needing CSS overrides. This eliminates the need for extensive CSS customizations in consuming projects.
+
+### Common Customizations
+
+#### Hide Sidebar Toggle Button (Hamburger Menu)
+
+By default, the sidebar toggle button is hidden (`show_sidebar_toggle={false}`). To show it:
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  show_sidebar_toggle={true}  // Show hamburger menu button
+/>
+```
+
+#### Hide Delete Button on Chat Bubbles
+
+To hide the delete button on chat bubbles:
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  show_delete_button={false}  // Hide delete button
+/>
+```
+
+#### Make Chat Bubbles Fully Round
+
+To make all chat bubbles fully round (instead of the default style with a tail):
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  bubble_radius="full"  // Fully round all corners
+/>
+```
+
+### Customization Props Summary
+
+| Prop | Default | Options | Description |
+|------|--------|---------|------------|
+| `show_sidebar_toggle` | `false` | `boolean` | Show/hide the hamburger menu button |
+| `show_delete_button` | `true` | `boolean` | Show/hide delete button on chat bubbles |
+| `bubble_radius` | `'default'` | `'default' \| 'full'` | Bubble border radius style |
+
+### Example: Full Customization
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  reference_id="project-456"
+  show_sidebar_toggle={false}    // Hide hamburger menu
+  show_delete_button={false}     // Hide delete buttons
+  bubble_radius="full"            // Fully round bubbles
+  title="Project Chat"
+  className="h-[600px]"
+/>
+```
+
+### Why Use Props Instead of CSS?
+
+Using props instead of CSS overrides provides:
+- **Type safety**: TypeScript will catch invalid values
+- **Consistency**: Ensures all instances use the same styling
+- **Maintainability**: Easier to update across the codebase
+- **No CSS conflicts**: Avoids specificity issues with Tailwind utilities
+
+If you need more advanced styling that isn't covered by props, you can still use CSS overrides, but props should cover most common customization needs.
+
+## Checking for Messages
+
+If you need to check whether messages exist for a given reference (without loading all messages), you can call the messages API endpoint directly. This is useful for showing indicators or badges.
+
+**Important:** The API requires `receiver_user_id` as a query parameter and returns an object response, not a direct array.
+
+### Correct API Usage Pattern
+
+```typescript
+// ✅ CORRECT: Include receiver_user_id and handle object response
+async function checkMessagesExist(
+  recipient_user_id: string,
+  reference_id: string,
+  reference_type?: string
+): Promise<boolean> {
+  const params = new URLSearchParams({
+    receiver_user_id: recipient_user_id,  // ✅ Required parameter
+    reference_id,
+    ...(reference_type && { reference_type }),
+  });
+
+  const response = await fetch(`/api/hazo_chat/messages?${params.toString()}`, {
+    credentials: 'include'
+  });
+
+  if (!response.ok) {
+    return false;
+  }
+
+  const data = await response.json();
+  
+  // ✅ Handle object response format: { success: true, messages: [], current_user_id }
+  const messages = data.messages || data;  // Handle both object and array responses
+  const has_messages_result = Array.isArray(messages) && messages.length > 0;
+  
+  return has_messages_result;
+}
+```
+
+### Common Mistakes to Avoid
+
+```typescript
+// ❌ WRONG: Missing receiver_user_id parameter
+const params = new URLSearchParams({
+  reference_id,
+  ...(reference_type && { reference_type }),
+});
+// This will return a 400 error: "receiver_user_id is required"
+
+// ❌ WRONG: Expecting direct array response
+const data = await response.json();
+const has_messages_result = Array.isArray(data) && data.length > 0;
+// This fails because API returns: { success: true, messages: [], current_user_id }
+```
+
+### Example: Custom Hook Implementation
+
+```typescript
+'use client';
+
+import { useState, useEffect } from 'react';
+
+function useChatMessagesCheck(
+  recipient_user_id: string,
+  reference_id: string,
+  reference_type?: string
+) {
+  const [has_messages, set_has_messages] = useState(false);
+  const [is_checking, set_is_checking] = useState(true);
+
+  useEffect(() => {
+    async function check() {
+      if (!recipient_user_id || !reference_id) {
+        set_is_checking(false);
+        return;
+      }
+
+      try {
+        const params = new URLSearchParams({
+          receiver_user_id: recipient_user_id,  // ✅ Required
+          reference_id,
+          ...(reference_type && { reference_type }),
+        });
+
+        const response = await fetch(
+          `/api/hazo_chat/messages?${params.toString()}`,
+          { credentials: 'include' }
+        );
+
+        if (response.ok) {
+          const data = await response.json();
+          const messages = data.messages || data;  // ✅ Handle object response
+          set_has_messages(Array.isArray(messages) && messages.length > 0);
+        }
+      } catch (error) {
+        console.error('[useChatMessagesCheck] Error:', error);
+        set_has_messages(false);
+      } finally {
+        set_is_checking(false);
+      }
+    }
+
+    check();
+  }, [recipient_user_id, reference_id, reference_type]);
+
+  return { has_messages, is_checking };
+}
+```
+
 ## Hooks
 
 ### useChatMessages
@@ -707,7 +1042,7 @@ npm run build:test-app
 import { HazoChat, useChatMessages, useChatReferences, useFileUpload } from 'hazo_chat';
 
 // API handlers (for server-side routes)
-import { createMessagesHandler } from 'hazo_chat/api';
+import { createMessagesHandler, createUnreadCountFunction } from 'hazo_chat/api';
 
 // Components only
 import { HazoChat, ChatBubble } from 'hazo_chat/components';

package/SETUP_CHECKLIST.md

@@ -233,11 +233,101 @@ export async function POST(request: NextRequest) {
 }
 ```
 
+### Step 4.4: Unread Count API (Optional - For Unread Badges)
+
+**File: `src/app/api/hazo_chat/unread_count/route.ts`**
+
+This endpoint is optional but useful for displaying unread message counts or badges in your UI.
+
+```typescript
+/**
+ * API route to get unread message counts grouped by reference_id
+ * Uses the exportable library function from hazo_chat
+ */
+
+export const dynamic = 'force-dynamic';
+
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+import { NextRequest, NextResponse } from 'next/server';
+
+// Create the unread count function using the factory
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const receiver_user_id = searchParams.get('receiver_user_id');
+
+    if (!receiver_user_id) {
+      return NextResponse.json(
+        { 
+          success: false, 
+          error: 'receiver_user_id is required',
+          unread_counts: []
+        },
+        { status: 400 }
+      );
+    }
+
+    // Call the library function
+    const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+
+    return NextResponse.json({
+      success: true,
+      receiver_user_id,
+      unread_counts,
+      total_references: unread_counts.length,
+      total_unread: unread_counts.reduce((sum, item) => sum + item.count, 0)
+    });
+  } catch (error) {
+    const error_message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('[hazo_chat/unread_count] Error:', error_message, error);
+    
+    return NextResponse.json(
+      { 
+        success: false, 
+        error: error_message,
+        unread_counts: []
+      },
+      { status: 500 }
+    );
+  }
+}
+```
+
+**What this endpoint does:**
+- Takes `receiver_user_id` as a query parameter
+- Returns an array of objects with `reference_id` and `count` of unread messages
+- Only counts messages where `read_at` is `null` and `deleted_at` is `null`
+- Groups results by `reference_id`
+- Sorts by count (descending - most unread first)
+
+**Response format:**
+```json
+{
+  "success": true,
+  "receiver_user_id": "user-123",
+  "unread_counts": [
+    { "reference_id": "ref-1", "count": 5 },
+    { "reference_id": "ref-2", "count": 3 },
+    { "reference_id": "", "count": 1 }
+  ],
+  "total_references": 3,
+  "total_unread": 9
+}
+```
+
+**Note:** This endpoint is optional. Only create it if you need to display unread message counts in your UI.
+
 ### API Routes Summary
 
 | Endpoint | Method | File | Purpose |
 |----------|--------|------|---------|
 | `/api/hazo_chat/messages` | GET, POST | `api/hazo_chat/messages/route.ts` | Message CRUD |
+| `/api/hazo_chat/unread_count` | GET | `api/hazo_chat/unread_count/route.ts` | Get unread counts (optional) |
 | `/api/hazo_auth/me` | GET | `api/hazo_auth/me/route.ts` | Get current user |
 | `/api/hazo_auth/profiles` | POST | `api/hazo_auth/profiles/route.ts` | Get user profiles |
 
@@ -246,6 +336,7 @@ export async function POST(request: NextRequest) {
 - [ ] `GET /api/hazo_auth/me` returns user data when logged in
 - [ ] `POST /api/hazo_auth/profiles` returns profiles for given IDs
 - [ ] `GET /api/hazo_chat/messages?receiver_user_id=xxx` works
+- [ ] `GET /api/hazo_chat/unread_count?receiver_user_id=xxx` returns unread counts (if implemented)
 
 ---
 
@@ -735,6 +826,9 @@ curl -X POST http://localhost:3000/api/hazo_auth/profiles \
 
 # Test messages endpoint
 curl "http://localhost:3000/api/hazo_chat/messages?receiver_user_id=user-id"
+
+# Test unread count endpoint (if implemented)
+curl "http://localhost:3000/api/hazo_chat/unread_count?receiver_user_id=user-id"
 ```
 
 ### UI Verification & Responsive Behavior
@@ -912,6 +1006,7 @@ npm install hazo_chat hazo_connect
 
 # 2. Create API routes
 mkdir -p src/app/api/hazo_chat/messages
+mkdir -p src/app/api/hazo_chat/unread_count  # Optional: for unread counts
 mkdir -p src/app/api/hazo_auth/me
 mkdir -p src/app/api/hazo_auth/profiles
 

package/dist/api/index.d.ts

@@ -20,5 +20,7 @@
  * ```
  */
 export { createMessagesHandler } from './messages.js';
+export { createUnreadCountFunction } from './unread_count.js';
 export type { MessagesHandlerOptions, ChatMessageInput, ChatMessageRecord } from './types.js';
+export type { UnreadCountFunctionOptions, UnreadCountResult } from './unread_count.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAGtD,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,0BAA0B,EAC1B,iBAAiB,EAClB,MAAM,mBAAmB,CAAC"}

package/dist/api/index.js

@@ -21,4 +21,5 @@
  */
 // Export handler factories
 export { createMessagesHandler } from './messages.js';
+export { createUnreadCountFunction } from './unread_count.js';
 //# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/api/unread_count.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Unread Count Library Function Factory
+ *
+ * Creates a function to get unread message counts grouped by reference_id
+ * for a given receiver user ID.
+ *
+ * @example
+ * ```typescript
+ * // In your server-side code
+ * import { createUnreadCountFunction } from 'hazo_chat/api';
+ * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+ *
+ * const getUnreadCount = createUnreadCountFunction({
+ *   getHazoConnect: () => getHazoConnectSingleton()
+ * });
+ *
+ * // Use the function
+ * const unreadCounts = await getUnreadCount('receiver-user-id-123');
+ * // Returns: [{ reference_id: 'ref-1', count: 5 }, { reference_id: 'ref-2', count: 3 }]
+ * ```
+ */
+/**
+ * Options for creating the unread count function
+ */
+export interface UnreadCountFunctionOptions {
+    /**
+     * Function to get the hazo_connect adapter instance.
+     * Called each time the function is invoked to get a fresh connection.
+     *
+     * @example
+     * ```typescript
+     * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+     *
+     * const options = {
+     *   getHazoConnect: () => getHazoConnectSingleton()
+     * };
+     * ```
+     */
+    getHazoConnect: () => unknown;
+}
+/**
+ * Result type for unread count function
+ */
+export interface UnreadCountResult {
+    /** The reference ID */
+    reference_id: string;
+    /** Number of unread messages for this reference */
+    count: number;
+}
+/**
+ * Creates a function to get unread message counts by reference_id
+ *
+ * @param options - Configuration options
+ * @returns Function that takes receiver_user_id and returns unread counts
+ */
+export declare function createUnreadCountFunction(options: UnreadCountFunctionOptions): (receiver_user_id: string) => Promise<UnreadCountResult[]>;
+//# sourceMappingURL=unread_count.d.ts.map

package/dist/api/unread_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unread_count.d.ts","sourceRoot":"","sources":["../../src/api/unread_count.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;;;;OAYG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uBAAuB;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,0BAA0B,IAUzE,kBAAkB,MAAM,KACvB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA2DhC"}

package/dist/api/unread_count.js

@@ -0,0 +1,86 @@
+/**
+ * Unread Count Library Function Factory
+ *
+ * Creates a function to get unread message counts grouped by reference_id
+ * for a given receiver user ID.
+ *
+ * @example
+ * ```typescript
+ * // In your server-side code
+ * import { createUnreadCountFunction } from 'hazo_chat/api';
+ * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+ *
+ * const getUnreadCount = createUnreadCountFunction({
+ *   getHazoConnect: () => getHazoConnectSingleton()
+ * });
+ *
+ * // Use the function
+ * const unreadCounts = await getUnreadCount('receiver-user-id-123');
+ * // Returns: [{ reference_id: 'ref-1', count: 5 }, { reference_id: 'ref-2', count: 3 }]
+ * ```
+ */
+import { createCrudService } from 'hazo_connect/server';
+/**
+ * Creates a function to get unread message counts by reference_id
+ *
+ * @param options - Configuration options
+ * @returns Function that takes receiver_user_id and returns unread counts
+ */
+export function createUnreadCountFunction(options) {
+    const { getHazoConnect } = options;
+    /**
+     * Get unread message counts grouped by reference_id for a receiver user
+     *
+     * @param receiver_user_id - The user ID to get unread counts for
+     * @returns Array of objects with reference_id and count of unread messages
+     */
+    return async function hazo_chat_get_unread_count(receiver_user_id) {
+        try {
+            if (!receiver_user_id || receiver_user_id.trim() === '') {
+                console.error('[hazo_chat_get_unread_count] Missing receiver_user_id');
+                return [];
+            }
+            console.log('[hazo_chat_get_unread_count] Fetching unread counts for:', {
+                receiver_user_id,
+            });
+            // Get hazo_connect instance and create CRUD service
+            const hazoConnect = getHazoConnect();
+            const chatService = createCrudService(hazoConnect, 'hazo_chat');
+            // Fetch all unread messages for this receiver
+            const unread_messages = await chatService.list((qb) => {
+                return qb
+                    .select('*')
+                    .where('receiver_user_id', 'eq', receiver_user_id)
+                    .where('read_at', 'is', null)
+                    .where('deleted_at', 'is', null);
+            });
+            // Group by reference_id and count
+            const count_map = new Map();
+            for (const message of unread_messages) {
+                const ref_id = message.reference_id || '';
+                const current_count = count_map.get(ref_id) || 0;
+                count_map.set(ref_id, current_count + 1);
+            }
+            // Convert map to array of results
+            const results = Array.from(count_map.entries()).map(([reference_id, count]) => ({
+                reference_id,
+                count,
+            }));
+            // Sort by count descending (most unread first)
+            results.sort((a, b) => b.count - a.count);
+            console.log('[hazo_chat_get_unread_count] Found unread counts:', {
+                receiver_user_id,
+                total_references: results.length,
+                total_unread: unread_messages.length,
+            });
+            return results;
+        }
+        catch (error) {
+            const error_message = error instanceof Error ? error.message : 'Unknown error';
+            console.error('[hazo_chat_get_unread_count] Error:', error_message, error);
+            // Return empty array on error rather than throwing
+            return [];
+        }
+    };
+}
+//# sourceMappingURL=unread_count.js.map

package/dist/api/unread_count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unread_count.js","sourceRoot":"","sources":["../../src/api/unread_count.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAkCxD;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CAAC,OAAmC;IAC3E,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAEnC;;;;;OAKG;IACH,OAAO,KAAK,UAAU,0BAA0B,CAC9C,gBAAwB;QAExB,IAAI,CAAC;YACH,IAAI,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBACxD,OAAO,CAAC,KAAK,CAAC,uDAAuD,CAAC,CAAC;gBACvE,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,0DAA0D,EAAE;gBACtE,gBAAgB;aACjB,CAAC,CAAC;YAEH,oDAAoD;YACpD,MAAM,WAAW,GAAG,cAAc,EAAwB,CAAC;YAC3D,MAAM,WAAW,GAAG,iBAAiB,CAAoB,WAAW,EAAE,WAAW,CAAC,CAAC;YAEnF,8CAA8C;YAC9C,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE;gBACpD,OAAO,EAAE;qBACN,MAAM,CAAC,GAAG,CAAC;qBACX,KAAK,CAAC,kBAAkB,EAAE,IAAI,EAAE,gBAAgB,CAAC;qBACjD,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC;qBAC5B,KAAK,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;YAEH,kCAAkC;YAClC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;YAE5C,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;gBACtC,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,IAAI,EAAE,CAAC;gBAC1C,MAAM,aAAa,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACjD,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC;YAC3C,CAAC;YAED,kCAAkC;YAClC,MAAM,OAAO,GAAwB,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CACtE,CAAC,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC1B,YAAY;gBACZ,KAAK;aACN,CAAC,CACH,CAAC;YAEF,+CAA+C;YAC/C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;YAE1C,OAAO,CAAC,GAAG,CAAC,mDAAmD,EAAE;gBAC/D,gBAAgB;gBAChB,gBAAgB,EAAE,OAAO,CAAC,MAAM;gBAChC,YAAY,EAAE,eAAe,CAAC,MAAM;aACrC,CAAC,CAAC;YAEH,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,aAAa,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;YAC/E,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;YAE3E,mDAAmD;YACnD,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/components/hazo_chat/hazo_chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hazo_chat.d.ts","sourceRoot":"","sources":["../../../src/components/hazo_chat/hazo_chat.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EACV,aAAa,EAId,MAAM,sBAAsB,CAAC;AA6Y9B;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAmD5C;yBAnDe,QAAQ"}
+{"version":3,"file":"hazo_chat.d.ts","sourceRoot":"","sources":["../../../src/components/hazo_chat/hazo_chat.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EACV,aAAa,EAId,MAAM,sBAAsB,CAAC;AAyZ9B;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAyD5C;yBAzDe,QAAQ"}