@knocklabs/client 0.14.10-canary.2 → 0.14.10

package/test/README.md

@@ -0,0 +1,590 @@
+# Testing Guide for Knock Client
+
+This directory contains all tests for the Knock JavaScript client. This guide will help you understand our testing patterns, utilities, and how to write effective tests.
+
+## 📁 Test Structure
+
+```
+test/
+├── README.md               # This guide
+├── setup.ts                # Global test configuration
+├── test-utils/             # Shared testing utilities
+│   ├── fixtures.ts         # Test data generators
+│   ├── mocks.ts            # Mock factories
+│   └── property-testing.ts # Property-based testing tools
+├── clients/                # Client-specific tests
+│   ├── feed/               # Feed client tests
+│   ├── messages/           # Messages client tests
+│   ├── users/              # Users client tests
+│   └── ...                 # Other client tests
+├── knock.test.ts           # Main Knock class tests
+├── api.test.ts             # API client tests
+├── helpers.test.ts         # Utility functions tests
+└── ...                     # Other core tests
+```
+
+## 🚀 Quick Start: Writing Your First Test
+
+Here's a simple test to get you started:
+
+```typescript
+import { describe, expect, test } from "vitest";
+
+import { createMockKnock } from "./test-utils/mocks";
+
+describe("My Feature", () => {
+  test("should do something", () => {
+    const { knock } = createMockKnock();
+
+    // Your test logic here
+    expect(knock).toBeDefined();
+  });
+});
+```
+
+**Important:** Always add `` at the top of test files.
+
+## 🛠 Test Utilities
+
+### 1. Fixtures (`test-utils/fixtures.ts`)
+
+Fixtures create realistic test data. Use them instead of manually creating objects.
+
+**Feed Items:**
+
+```typescript
+import {
+  createArchivedFeedItem,
+  createMockFeedItem,
+  createReadFeedItem,
+  createUnreadFeedItem,
+} from "./test-utils/fixtures";
+
+// Create a basic feed item
+const item = createMockFeedItem();
+
+// Create specific states
+const unreadItem = createUnreadFeedItem();
+const readItem = createReadFeedItem({
+  read_at: "2024-01-01T00:00:00Z",
+});
+
+// Create multiple items
+const items = createMockFeedItems(5);
+```
+
+**Messages:**
+
+```typescript
+import {
+  createMockMessage,
+  createReadMessage,
+  createUnreadMessage,
+} from "./test-utils/fixtures";
+
+const message = createMockMessage({
+  id: "custom-id",
+});
+```
+
+**Users:**
+
+```typescript
+import { createMockUser, createMockUsers } from "./test-utils/fixtures";
+
+const user = createMockUser({ name: "John Doe" });
+const users = createMockUsers(10);
+```
+
+**Complex Scenarios:**
+
+```typescript
+import {
+  createBulkOperationScenario,
+  createErrorRecoveryScenario,
+  createUserJourneyScenario,
+} from "./test-utils/fixtures";
+
+// Pre-built realistic test scenarios
+const scenario = createUserJourneyScenario();
+```
+
+### 2. Mocks (`test-utils/mocks.ts`)
+
+Mocks handle external dependencies and API calls.
+
+**Basic Setup:**
+
+```typescript
+import { authenticateKnock, createMockKnock } from "./test-utils/mocks";
+
+test("my test", () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // Authenticate if needed
+  authenticateKnock(knock);
+
+  // Your test logic
+});
+```
+
+**API Mocking:**
+
+```typescript
+import {
+  mockNetworkError,
+  mockNetworkFailure,
+  mockNetworkSuccess,
+} from "./test-utils/mocks";
+
+test("handles successful API call", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // Mock successful response
+  mockNetworkSuccess(mockApiClient, { data: "success" });
+
+  // Test your code
+});
+
+test("handles API error", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // Mock error response
+  mockNetworkError(mockApiClient, 400, "Bad Request");
+
+  // Test error handling
+});
+
+test("handles network failure", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // Mock network failure
+  mockNetworkFailure(mockApiClient, new Error("Network down"));
+
+  // Test failure handling
+});
+```
+
+**Feed Mocking:**
+
+```typescript
+import { createMockFeed } from "./test-utils/mocks";
+
+test("feed operations", () => {
+  const { feed, mockApiClient, mockSocketManager } = createMockFeed(
+    "test-feed-id",
+    { page_size: 25 },
+  );
+
+  // Test feed operations
+});
+```
+
+### 3. Property Testing (`test-utils/property-testing.ts`)
+
+Property testing helps find edge cases by testing with generated data.
+
+```typescript
+import {
+  feedItemArbitrary,
+  generators,
+  property,
+} from "./test-utils/property-testing";
+
+test("property: all feed items should have valid IDs", async () => {
+  const result = await property.forAll(
+    feedItemArbitrary(),
+    (item) => item.id.length > 0,
+  );
+
+  expect(result.success).toBe(true);
+});
+
+test("property: numbers are always positive", async () => {
+  const result = await property.forAll(
+    generators.number(1, 1000),
+    (num) => num > 0,
+  );
+
+  expect(result.success).toBe(true);
+});
+```
+
+## 📝 Testing Patterns
+
+### 1. Test Organization
+
+**Use descriptive describe blocks:**
+
+```typescript
+describe("Feed Client", () => {
+  describe("Initialization", () => {
+    test("creates feed with valid options", () => {
+      // Test initialization
+    });
+  });
+
+  describe("Data Operations", () => {
+    test("fetches feed items successfully", () => {
+      // Test data fetching
+    });
+  });
+
+  describe("Error Handling", () => {
+    test("handles network errors gracefully", () => {
+      // Test error scenarios
+    });
+  });
+});
+```
+
+### 2. Setup and Cleanup
+
+**Use consistent setup:**
+
+```typescript
+import { afterEach, beforeEach, describe, test, vi } from "vitest";
+
+describe("My Feature", () => {
+  const getTestSetup = () => {
+    const { knock, mockApiClient } = createMockKnock();
+    authenticateKnock(knock);
+
+    return {
+      knock,
+      mockApiClient,
+      cleanup: () => vi.clearAllMocks(),
+    };
+  };
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("my test", () => {
+    const { knock, mockApiClient, cleanup } = getTestSetup();
+
+    try {
+      // Your test logic
+    } finally {
+      cleanup();
+    }
+  });
+});
+```
+
+### 3. Async Testing
+
+**Handle promises correctly:**
+
+```typescript
+test("async operation succeeds", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  mockNetworkSuccess(mockApiClient, { success: true });
+
+  const result = await knock.someAsyncOperation();
+
+  expect(result).toEqual({ success: true });
+});
+
+test("async operation fails", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  mockNetworkFailure(mockApiClient, new Error("Failed"));
+
+  await expect(knock.someAsyncOperation()).rejects.toThrow("Failed");
+});
+```
+
+### 4. State Testing
+
+**Test different states:**
+
+```typescript
+test("handles unread items", () => {
+  const items = [
+    createUnreadFeedItem(),
+    createReadFeedItem(),
+    createUnreadFeedItem(),
+  ];
+
+  const unreadCount = items.filter((item) => !item.read_at).length;
+  expect(unreadCount).toBe(2);
+});
+```
+
+## 🎯 Testing Specific Clients
+
+### Feed Client Tests
+
+```typescript
+import { createMockFeedItems } from "./test-utils/fixtures";
+import { createMockFeed } from "./test-utils/mocks";
+
+test("feed fetches items", async () => {
+  const { feed, mockApiClient } = createMockFeed();
+  const items = createMockFeedItems(5);
+
+  mockNetworkSuccess(mockApiClient, {
+    entries: items,
+    page_info: { page_size: 50 },
+  });
+
+  await feed.fetch();
+
+  expect(feed.store.items).toHaveLength(5);
+});
+```
+
+### Messages Client Tests
+
+```typescript
+import { createMockMessage } from "./test-utils/fixtures";
+
+test("messages client gets message", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+  const message = createMockMessage();
+
+  mockNetworkSuccess(mockApiClient, message);
+
+  const result = await knock.messages.get(message.id);
+
+  expect(result).toEqual(message);
+});
+```
+
+### User Client Tests
+
+```typescript
+test("user client identifies user", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  mockNetworkSuccess(mockApiClient, { success: true });
+
+  await knock.user.identify("user_123", { name: "John" });
+
+  expect(mockApiClient.makeRequest).toHaveBeenCalledWith({
+    method: "PUT",
+    url: "/v1/users/user_123",
+    data: { name: "John" },
+  });
+});
+```
+
+## 🧪 Advanced Testing
+
+### Error Scenarios
+
+```typescript
+test("handles rate limiting", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  mockNetworkError(mockApiClient, 429, "Rate limited");
+
+  await expect(knock.someOperation()).rejects.toThrow();
+});
+
+test("retries on network failure", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // First call fails, second succeeds
+  mockApiClient.makeRequest
+    .mockRejectedValueOnce(new Error("Network error"))
+    .mockResolvedValueOnce({ statusCode: "ok", body: { success: true } });
+
+  const result = await knock.someRetryableOperation();
+
+  expect(result).toEqual({ success: true });
+  expect(mockApiClient.makeRequest).toHaveBeenCalledTimes(2);
+});
+```
+
+### Performance Testing
+
+```typescript
+import { createLargeFeedDataset } from "./test-utils/fixtures";
+
+test("handles large datasets efficiently", () => {
+  const { items, metadata } = createLargeFeedDataset(10000);
+
+  const startTime = performance.now();
+
+  // Test operation
+  const result = processLargeDataset(items);
+
+  const endTime = performance.now();
+
+  expect(result).toBeDefined();
+  expect(endTime - startTime).toBeLessThan(1000); // Should complete in < 1s
+});
+```
+
+## 🔧 Configuration
+
+### Global Setup (`setup.ts`)
+
+The setup file handles:
+
+- Environment polyfills
+- Console output suppression during tests
+- Global error handling
+- Browser API mocks (localStorage, sessionStorage)
+
+You usually don't need to modify this file.
+
+### Environment
+
+All tests should run in Node environment:
+
+```typescript
+
+```
+
+## 🚨 Common Issues & Solutions
+
+### 1. Unhandled Promise Rejections
+
+**Problem:** Tests fail with unhandled promise rejections.
+
+**Solution:** Always handle promises properly:
+
+```typescript
+// ❌ Bad
+test("test", () => {
+  someAsyncFunction(); // Promise not handled
+});
+
+// ✅ Good
+test("test", async () => {
+  await someAsyncFunction();
+});
+
+// ✅ Also good
+test("test", () => {
+  return someAsyncFunction();
+});
+```
+
+### 2. Mock Cleanup
+
+**Problem:** Mocks from one test affect another.
+
+**Solution:** Always clean up:
+
+```typescript
+afterEach(() => {
+  vi.clearAllMocks();
+  vi.restoreAllMocks();
+});
+```
+
+### 3. Authentication Required
+
+**Problem:** Tests fail because client isn't authenticated.
+
+**Solution:** Use `authenticateKnock`:
+
+```typescript
+test("authenticated operation", () => {
+  const { knock } = createMockKnock();
+  authenticateKnock(knock); // Add this line
+
+  // Now test authenticated operations
+});
+```
+
+### 4. Network Mocking
+
+**Problem:** Real network calls in tests.
+
+**Solution:** Always mock network calls:
+
+```typescript
+test("API operation", async () => {
+  const { knock, mockApiClient } = createMockKnock();
+
+  // Mock the expected response
+  mockNetworkSuccess(mockApiClient, expectedData);
+
+  const result = await knock.apiOperation();
+
+  expect(result).toEqual(expectedData);
+});
+```
+
+## 📚 Examples
+
+### Complete Test File Example
+
+```typescript
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import { createMockFeedItem } from "./test-utils/fixtures";
+import {
+  authenticateKnock,
+  createMockKnock,
+  mockNetworkSuccess,
+} from "./test-utils/mocks";
+
+describe("My Feature", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("Basic Operations", () => {
+    test("performs basic operation", () => {
+      const { knock } = createMockKnock();
+
+      expect(knock).toBeDefined();
+    });
+  });
+
+  describe("Authenticated Operations", () => {
+    test("performs authenticated operation", async () => {
+      const { knock, mockApiClient } = createMockKnock();
+      authenticateKnock(knock);
+
+      const expectedData = { success: true };
+      mockNetworkSuccess(mockApiClient, expectedData);
+
+      const result = await knock.authenticatedOperation();
+
+      expect(result).toEqual(expectedData);
+    });
+  });
+
+  describe("Data Operations", () => {
+    test("processes feed item", () => {
+      const item = createMockFeedItem({
+        read_at: null, // Unread item
+      });
+
+      const result = processItem(item);
+
+      expect(result.isUnread).toBe(true);
+    });
+  });
+
+  describe("Error Handling", () => {
+    test("handles errors gracefully", async () => {
+      const { knock, mockApiClient } = createMockKnock();
+
+      mockApiClient.makeRequest.mockRejectedValue(new Error("API Error"));
+
+      await expect(knock.faultyOperation()).rejects.toThrow("API Error");
+    });
+  });
+});
+```
+
+## 🎉 You're Ready!
+
+With this guide and the provided utilities, you should be able to write comprehensive tests for any part of the Knock client. Remember:
+
+1. **Use the test utilities** - they handle the complex setup for you
+2. **Follow the patterns** - consistent structure makes tests easier to understand
+3. **Test both success and failure cases** - robust testing catches more bugs
+4. **Clean up after yourself** - prevent test pollution
+
+Happy testing! 🧪

package/dist/cjs/api.js

@@ -1,2 +0,0 @@
-"use strict";var i=Object.defineProperty;var n=(t,e,s)=>e in t?i(t,e,{enumerable:!0,configurable:!0,writable:!0,value:s}):t[e]=s;var r=(t,e,s)=>n(t,typeof e!="symbol"?e+"":e,s);Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const u=require("axios"),l=require("axios-retry"),c=require("phoenix"),a=t=>t&&typeof t=="object"&&"default"in t?t:{default:t},p=a(u),o=a(l);class d{constructor(e){r(this,"host");r(this,"apiKey");r(this,"userToken");r(this,"axiosClient");r(this,"socket");this.host=e.host,this.apiKey=e.apiKey,this.userToken=e.userToken||null,this.axiosClient=p.default.create({baseURL:this.host,headers:{Accept:"application/json","Content-Type":"application/json",Authorization:`Bearer ${this.apiKey}`,"X-Knock-User-Token":this.userToken}}),typeof window<"u"&&(this.socket=new c.Socket(`${this.host.replace("http","ws")}/ws/v1`,{params:{user_token:this.userToken,api_key:this.apiKey}})),o.default(this.axiosClient,{retries:3,retryCondition:this.canRetryRequest,retryDelay:o.default.exponentialDelay})}async makeRequest(e){try{const s=await this.axiosClient(e);return{statusCode:s.status<300?"ok":"error",body:s.data,error:void 0,status:s.status}}catch(s){return console.error(s),{statusCode:"error",status:500,body:void 0,error:s}}}canRetryRequest(e){return o.default.isNetworkError(e)?!0:e.response?e.response.status>=500&&e.response.status<=599||e.response.status===429:!1}}exports.default=d;
-//# sourceMappingURL=api.js.map

package/dist/cjs/api.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.js","sources":["../../src/api.ts"],"sourcesContent":["import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from \"axios\";\nimport axiosRetry from \"axios-retry\";\nimport { Socket } from \"phoenix\";\n\ntype ApiClientOptions = {\n  host: string;\n  apiKey: string;\n  userToken: string | undefined;\n};\n\nexport interface ApiResponse {\n  // eslint-disable-next-line\n  error?: any;\n  // eslint-disable-next-line\n  body?: any;\n  statusCode: \"ok\" | \"error\";\n  status: number;\n}\n\nclass ApiClient {\n  private host: string;\n  private apiKey: string;\n  private userToken: string | null;\n  private axiosClient: AxiosInstance;\n\n  public socket: Socket | undefined;\n\n  constructor(options: ApiClientOptions) {\n    this.host = options.host;\n    this.apiKey = options.apiKey;\n    this.userToken = options.userToken || null;\n\n    // Create a retryable axios client\n    this.axiosClient = axios.create({\n      baseURL: this.host,\n      headers: {\n        Accept: \"application/json\",\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.apiKey}`,\n        \"X-Knock-User-Token\": this.userToken,\n      },\n    });\n\n    if (typeof window !== \"undefined\") {\n      this.socket = new Socket(`${this.host.replace(\"http\", \"ws\")}/ws/v1`, {\n        params: {\n          user_token: this.userToken,\n          api_key: this.apiKey,\n        },\n      });\n    }\n\n    axiosRetry(this.axiosClient, {\n      retries: 3,\n      retryCondition: this.canRetryRequest,\n      retryDelay: axiosRetry.exponentialDelay,\n    });\n  }\n\n  async makeRequest(req: AxiosRequestConfig): Promise<ApiResponse> {\n    try {\n      const result = await this.axiosClient(req);\n\n      return {\n        statusCode: result.status < 300 ? \"ok\" : \"error\",\n        body: result.data,\n        error: undefined,\n        status: result.status,\n      };\n\n      // eslint:disable-next-line\n    } catch (e: unknown) {\n      console.error(e);\n\n      return {\n        statusCode: \"error\",\n        status: 500,\n        body: undefined,\n        error: e,\n      };\n    }\n  }\n\n  private canRetryRequest(error: AxiosError) {\n    // Retry Network Errors.\n    if (axiosRetry.isNetworkError(error)) {\n      return true;\n    }\n\n    if (!error.response) {\n      // Cannot determine if the request can be retried\n      return false;\n    }\n\n    // Retry Server Errors (5xx).\n    if (error.response.status >= 500 && error.response.status <= 599) {\n      return true;\n    }\n\n    // Retry if rate limited.\n    if (error.response.status === 429) {\n      return true;\n    }\n\n    return false;\n  }\n}\n\nexport default ApiClient;\n"],"names":["ApiClient","options","__publicField","axios","Socket","axiosRetry","req","result","e","error"],"mappings":"6ZAmBA,MAAMA,CAAU,CAQd,YAAYC,EAA2B,CAP/BC,EAAA,aACAA,EAAA,eACAA,EAAA,kBACAA,EAAA,oBAEDA,EAAA,eAGL,KAAK,KAAOD,EAAQ,KACpB,KAAK,OAASA,EAAQ,OACjB,KAAA,UAAYA,EAAQ,WAAa,KAGjC,KAAA,YAAcE,UAAM,OAAO,CAC9B,QAAS,KAAK,KACd,QAAS,CACP,OAAQ,mBACR,eAAgB,mBAChB,cAAe,UAAU,KAAK,MAAM,GACpC,qBAAsB,KAAK,SAAA,CAC7B,CACD,EAEG,OAAO,OAAW,MACf,KAAA,OAAS,IAAIC,EAAA,OAAO,GAAG,KAAK,KAAK,QAAQ,OAAQ,IAAI,CAAC,SAAU,CACnE,OAAQ,CACN,WAAY,KAAK,UACjB,QAAS,KAAK,MAAA,CAChB,CACD,GAGHC,EAAA,QAAW,KAAK,YAAa,CAC3B,QAAS,EACT,eAAgB,KAAK,gBACrB,WAAYA,EAAAA,QAAW,gBAAA,CACxB,CAAA,CAGH,MAAM,YAAYC,EAA+C,CAC3D,GAAA,CACF,MAAMC,EAAS,MAAM,KAAK,YAAYD,CAAG,EAElC,MAAA,CACL,WAAYC,EAAO,OAAS,IAAM,KAAO,QACzC,KAAMA,EAAO,KACb,MAAO,OACP,OAAQA,EAAO,MACjB,QAGOC,EAAY,CACnB,eAAQ,MAAMA,CAAC,EAER,CACL,WAAY,QACZ,OAAQ,IACR,KAAM,OACN,MAAOA,CACT,CAAA,CACF,CAGM,gBAAgBC,EAAmB,CAErC,OAAAJ,EAAA,QAAW,eAAeI,CAAK,EAC1B,GAGJA,EAAM,SAMPA,EAAM,SAAS,QAAU,KAAOA,EAAM,SAAS,QAAU,KAKzDA,EAAM,SAAS,SAAW,IATrB,EAaF,CAEX"}

package/dist/cjs/clients/feed/feed.js

@@ -1,2 +0,0 @@
-"use strict";var g=Object.defineProperty;var p=(c,e,t)=>e in c?g(c,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):c[e]=t;var d=(c,e,t)=>p(c,typeof e!="symbol"?e+"":e,t);Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const k=require("eventemitter2"),_=require("nanoid"),v=require("../../helpers.js"),m=require("../../networkStatus.js"),S=require("./socket-manager.js"),y=require("./store.js"),f=require("./utils.js"),b=c=>c&&typeof c=="object"&&"default"in c?c:{default:c},w=b(k),I={archived:"exclude"},C=2e3,U="client_";class A{constructor(e,t,s,a){d(this,"defaultOptions");d(this,"referenceId");d(this,"unsubscribeFromSocketEvents");d(this,"socketManager");d(this,"userFeedId");d(this,"broadcaster");d(this,"broadcastChannel");d(this,"disconnectTimer",null);d(this,"hasSubscribedToRealTimeUpdates",!1);d(this,"visibilityChangeHandler",()=>{});d(this,"visibilityChangeListenerConnected",!1);d(this,"store");this.knock=e,this.feedId=t,(!t||!v.isValidUuid(t))&&this.knock.log("[Feed] Invalid or missing feedId provided to the Feed constructor. The feed should be a UUID of an in-app feed channel (`in_app_feed`) found in the Knock dashboard. Please provide a valid feedId to the Feed constructor.",!0),this.feedId=t,this.userFeedId=this.buildUserFeedId(),this.referenceId=U+_.nanoid(),this.socketManager=a,this.store=y.default(),this.broadcaster=new w.default({wildcard:!0,delimiter:"."}),this.defaultOptions={...I,...f.mergeDateRangeParams(s)},this.knock.log(`[Feed] Initialized a feed on channel ${t}`),this.initializeRealtimeConnection(),this.setupBroadcastChannel()}reinitialize(e){this.socketManager=e,this.userFeedId=this.buildUserFeedId(),this.initializeRealtimeConnection(),this.setupBroadcastChannel()}teardown(){var e;this.knock.log("[Feed] Tearing down feed instance"),(e=this.socketManager)==null||e.leave(this),this.tearDownVisibilityListeners(),this.disconnectTimer&&(clearTimeout(this.disconnectTimer),this.disconnectTimer=null),this.broadcastChannel&&this.broadcastChannel.close()}dispose(){this.knock.log("[Feed] Disposing of feed instance"),this.teardown(),this.broadcaster.removeAllListeners(),this.knock.feeds.removeInstance(this)}listenForUpdates(){var e;if(this.knock.log("[Feed] Connecting to real-time service"),this.hasSubscribedToRealTimeUpdates=!0,!this.knock.isAuthenticated()){this.knock.log("[Feed] User is not authenticated, skipping listening for updates");return}this.unsubscribeFromSocketEvents=(e=this.socketManager)==null?void 0:e.join(this)}on(e,t){this.broadcaster.on(e,t)}off(e,t){this.broadcaster.off(e,t)}getState(){return this.store.getState()}async markAsSeen(e){const t=new Date().toISOString();return this.optimisticallyPerformStatusUpdate(e,"seen",{seen_at:t},"unseen_count"),this.makeStatusUpdate(e,"seen")}async markAllAsSeen(){const{metadata:e,items:t,...s}=this.store.getState();if(this.defaultOptions.status==="unseen")s.resetStore({...e,total_count:0,unseen_count:0});else{s.setMetadata({...e,unseen_count:0});const n={seen_at:new Date().toISOString()},i=t.map(o=>o.id);s.setItemAttrs(i,n)}const r=await this.makeBulkStatusUpdate("seen");return this.emitEvent("all_seen",t),r}async markAsUnseen(e){return this.optimisticallyPerformStatusUpdate(e,"unseen",{seen_at:null},"unseen_count"),this.makeStatusUpdate(e,"unseen")}async markAsRead(e){const t=new Date().toISOString();return this.optimisticallyPerformStatusUpdate(e,"read",{read_at:t},"unread_count"),this.makeStatusUpdate(e,"read")}async markAllAsRead(){const{metadata:e,items:t,...s}=this.store.getState();if(this.defaultOptions.status==="unread")s.resetStore({...e,total_count:0,unread_count:0});else{s.setMetadata({...e,unread_count:0});const n={read_at:new Date().toISOString()},i=t.map(o=>o.id);s.setItemAttrs(i,n)}const r=await this.makeBulkStatusUpdate("read");return this.emitEvent("all_read",t),r}async markAsUnread(e){return this.optimisticallyPerformStatusUpdate(e,"unread",{read_at:null},"unread_count"),this.makeStatusUpdate(e,"unread")}async markAsInteracted(e,t){const s=new Date().toISOString();return this.optimisticallyPerformStatusUpdate(e,"interacted",{read_at:s,interacted_at:s},"unread_count"),this.makeStatusUpdate(e,"interacted",t)}async markAsArchived(e){const t=this.store.getState(),s=this.defaultOptions.archived==="exclude",a=Array.isArray(e)?e:[e],r=a.map(n=>n.id);if(s){const n=a.filter(u=>!u.seen_at).length,i=a.filter(u=>!u.read_at).length,o={...t.metadata,total_count:Math.max(0,t.metadata.total_count-a.length),unseen_count:Math.max(0,t.metadata.unseen_count-n),unread_count:Math.max(0,t.metadata.unread_count-i)},l=t.items.filter(u=>!r.includes(u.id));t.setResult({entries:l,meta:o,page_info:t.pageInfo})}else t.setItemAttrs(r,{archived_at:new Date().toISOString()});return this.makeStatusUpdate(e,"archived")}async markAllAsArchived(){const{items:e,...t}=this.store.getState();if(this.defaultOptions.archived==="exclude")t.resetStore();else{const r=e.map(n=>n.id);t.setItemAttrs(r,{archived_at:new Date().toISOString()})}const a=await this.makeBulkStatusUpdate("archive");return this.emitEvent("all_archived",e),a}async markAllReadAsArchived(){const{items:e,...t}=this.store.getState(),a=e.filter(i=>i.read_at===null).map(i=>i.id);if(t.setItemAttrs(a,{archived_at:new Date().toISOString()}),this.defaultOptions.archived==="exclude"){const i=e.filter(l=>!a.includes(l.id)),o={...t.metadata,total_count:i.length,unread_count:0};t.setResult({entries:i,meta:o,page_info:t.pageInfo})}return await this.makeBulkStatusUpdate("archive")}async markAsUnarchived(e){return this.optimisticallyPerformStatusUpdate(e,"unarchived",{archived_at:null}),this.makeStatusUpdate(e,"unarchived")}async fetch(e={}){const{networkStatus:t,...s}=this.store.getState();if(!this.knock.isAuthenticated()){this.knock.log("[Feed] User is not authenticated, skipping fetch");return}if(m.isRequestInFlight(t)){this.knock.log("[Feed] Request is in flight, skipping fetch");return}s.setNetworkStatus(e.__loadingType??m.NetworkStatus.loading);const a=f.getFormattedTriggerData({...this.defaultOptions,...e}),r={...this.defaultOptions,...f.mergeDateRangeParams(e),trigger_data:a,__loadingType:void 0,__fetchSource:void 0,__experimentalCrossBrowserUpdates:void 0,auto_manage_socket_connection:void 0,auto_manage_socket_connection_delay:void 0},n=await this.knock.client().makeRequest({method:"GET",url:`/v1/users/${this.knock.userId}/feeds/${this.feedId}`,params:r});if(n.statusCode==="error"||!n.body)return s.setNetworkStatus(m.NetworkStatus.error),{status:n.statusCode,data:n.error||n.body};const i={entries:n.body.entries,meta:n.body.meta,page_info:n.body.page_info};if(e.before){const u={shouldSetPage:!1,shouldAppend:!0};s.setResult(i,u)}else if(e.after){const u={shouldSetPage:!0,shouldAppend:!0};s.setResult(i,u)}else s.setResult(i);this.broadcast("messages.new",i);const o=e.__fetchSource==="socket"?"items.received.realtime":"items.received.page",l={items:i.entries,metadata:i.meta,event:o};return this.broadcast(l.event,l),{data:i,status:n.statusCode}}async fetchNextPage(e={}){const{pageInfo:t}=this.store.getState();t.after&&this.fetch({...e,after:t.after,__loadingType:m.NetworkStatus.fetchMore})}get socketChannelTopic(){return`feeds:${this.userFeedId}`}broadcast(e,t){this.broadcaster.emit(e,t)}async onNewMessageReceived({data:e}){var n;this.knock.log("[Feed] Received new real-time message");const{items:t,...s}=this.store.getState(),a=t[0],r=(n=e[this.referenceId])==null?void 0:n.metadata;r&&s.setMetadata(r),this.fetch({before:a==null?void 0:a.__cursor,__fetchSource:"socket"})}buildUserFeedId(){return`${this.feedId}:${this.knock.userId}`}optimisticallyPerformStatusUpdate(e,t,s,a){const r=this.store.getState(),n=Array.isArray(e)?e:[e],i=n.map(o=>o.id);if(a){const{metadata:o}=r,l=n.filter(h=>{switch(t){case"seen":return h.seen_at===null;case"unseen":return h.seen_at!==null;case"read":case"interacted":return h.read_at===null;case"unread":return h.read_at!==null;default:return!0}}),u=t.startsWith("un")?l.length:-l.length;r.setMetadata({...o,[a]:Math.max(0,o[a]+u)})}r.setItemAttrs(i,s)}async makeStatusUpdate(e,t,s){const a=Array.isArray(e)?e:[e],r=a.map(i=>i.id),n=await this.knock.messages.batchUpdateStatuses(r,t,{metadata:s});return this.emitEvent(t,a),n}async makeBulkStatusUpdate(e){const t={user_ids:[this.knock.userId],engagement_status:this.defaultOptions.status!=="all"?this.defaultOptions.status:void 0,archived:this.defaultOptions.archived,has_tenant:this.defaultOptions.has_tenant,tenants:this.defaultOptions.tenant?[this.defaultOptions.tenant]:void 0};return await this.knock.messages.bulkUpdateAllStatusesInChannel({channelId:this.feedId,status:e,options:t})}setupBroadcastChannel(){this.broadcastChannel=typeof self<"u"&&"BroadcastChannel"in self?new BroadcastChannel(`knock:feed:${this.userFeedId}`):null,this.broadcastChannel&&this.defaultOptions.__experimentalCrossBrowserUpdates===!0&&(this.broadcastChannel.onmessage=e=>{switch(e.data.type){case"items:archived":case"items:unarchived":case"items:seen":case"items:unseen":case"items:read":case"items:unread":case"items:all_read":case"items:all_seen":case"items:all_archived":return this.fetch();default:return null}})}broadcastOverChannel(e,t){if(this.broadcastChannel)try{const s=JSON.parse(JSON.stringify(t));this.broadcastChannel.postMessage({type:e,payload:s})}catch(s){console.warn(`Could not broadcast ${e}, got error: ${s}`)}}initializeRealtimeConnection(){var e;this.socketManager&&(this.defaultOptions.auto_manage_socket_connection&&this.setUpVisibilityListeners(),this.hasSubscribedToRealTimeUpdates&&this.knock.isAuthenticated()&&(this.unsubscribeFromSocketEvents=(e=this.socketManager)==null?void 0:e.join(this)))}async handleSocketEvent(e){switch(e.event){case S.SocketEventType.NewMessage:this.onNewMessageReceived(e);return;default:{e.event;return}}}setUpVisibilityListeners(){typeof document>"u"||this.visibilityChangeListenerConnected||(this.visibilityChangeHandler=this.handleVisibilityChange.bind(this),this.visibilityChangeListenerConnected=!0,document.addEventListener("visibilitychange",this.visibilityChangeHandler))}tearDownVisibilityListeners(){typeof document>"u"||(document.removeEventListener("visibilitychange",this.visibilityChangeHandler),this.visibilityChangeListenerConnected=!1)}emitEvent(e,t){this.broadcaster.emit(`items.${e}`,{items:t}),this.broadcaster.emit(`items:${e}`,{items:t}),this.broadcastOverChannel(`items:${e}`,{items:t})}handleVisibilityChange(){var s,a;const e=this.defaultOptions.auto_manage_socket_connection_delay??C,t=this.knock.client();document.visibilityState==="hidden"?this.disconnectTimer=setTimeout(()=>{var r;(r=t.socket)==null||r.disconnect(),this.disconnectTimer=null},e):document.visibilityState==="visible"&&(this.disconnectTimer&&(clearTimeout(this.disconnectTimer),this.disconnectTimer=null),(s=t.socket)!=null&&s.isConnected()||(a=t.socket)==null||a.connect())}}exports.default=A;
-//# sourceMappingURL=feed.js.map