c15t 0.0.1-rc.3

package/dist/types/index.cjs

@@ -0,0 +1,44 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.d = function (exports1, definition) {
+		for (var key in definition)
+			if (
+				__webpack_require__.o(definition, key) &&
+				!__webpack_require__.o(exports1, key)
+			)
+				Object.defineProperty(exports1, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+	};
+})();
+(() => {
+	__webpack_require__.o = function (obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	};
+})();
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+	consentTypes: () => external_gdpr_cjs_namespaceObject.consentTypes,
+});
+const external_gdpr_cjs_namespaceObject = require('./gdpr.cjs');
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/types/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @packageDocumentation
+ * Central export point for all consent management types and interfaces.
+ * This module aggregates and re-exports all type definitions needed for implementing
+ * GDPR-compliant consent management.
+ */
+/**
+ * @module
+ * Compliance and Privacy Types
+ *
+ * @remarks
+ * Exports types related to privacy compliance and consent management:
+ * - Region-specific compliance settings
+ * - Consent state tracking
+ * - Privacy preferences
+ * - Namespace configuration
+ *
+ * @example
+ * Import compliance-related types:
+ * ```typescript
+ * import type {
+ *   ComplianceRegion,
+ *   ComplianceSettings,
+ *   PrivacySettings
+ * } from 'c15t/types';
+ *
+ * const euSettings: ComplianceSettings = {
+ *   enabled: true,
+ *   appliesGlobally: false,
+ *   applies: true
+ * };
+ *
+ * const region: ComplianceRegion = 'gdpr';
+ * ```
+ */
+import type {
+	ComplianceRegion,
+	ComplianceSettings,
+	ConsentState,
+	HasConsentedProps,
+	NamespaceProps,
+	PrivacySettings,
+} from './compliance';
+export type {
+	ConsentState,
+	ComplianceRegion,
+	ComplianceSettings,
+	PrivacySettings,
+	HasConsentedProps,
+	NamespaceProps,
+};
+/**
+ * @module
+ * GDPR Consent Types
+ *
+ * @remarks
+ * Exports types and constants for GDPR-specific consent management:
+ * - Consent category definitions
+ * - Consent type configurations
+ * - Predefined consent settings
+ *
+ * @example
+ * Import and use GDPR-related types:
+ * ```typescript
+ * import {
+ *   type AllConsentNames,
+ *   type ConsentType,
+ *   consentTypes
+ * } from 'c15t/types';
+ *
+ * function isOptionalConsent(type: AllConsentNames): boolean {
+ *   const config = consentTypes.find(c => c.name === type);
+ *   return config ? !config.disabled && !config.defaultValue : false;
+ * }
+ * ```
+ */
+import { type AllConsentNames, type ConsentType, consentTypes } from './gdpr';
+export { consentTypes };
+export type { AllConsentNames, ConsentType };
+/**
+ * @module
+ * Callback Types
+ *
+ * @remarks
+ * Exports types for consent management callbacks and event handlers:
+ * - Generic callback function type
+ * - Consent-specific callback configurations
+ *
+ * @example
+ * Import and use callback types:
+ * ```typescript
+ * import type {
+ *   CallbackFunction,
+ *   Callbacks
+ * } from 'c15t/types';
+ *
+ * const callbacks: Callbacks = {
+ *   onConsentGiven: () => {
+ *     console.log('Consent granted');
+ *     initializeAnalytics();
+ *   },
+ *   onError: (error) => {
+ *     console.error('Consent error:', error);
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * Create typed callback functions:
+ * ```typescript
+ * const errorHandler: CallbackFunction<string> =
+ *   (message) => console.error(message);
+ *
+ * const readyHandler: CallbackFunction =
+ *   () => console.log('System ready');
+ * ```
+ */
+import type { CallbackFunction, Callbacks } from './callbacks';
+export type { CallbackFunction, Callbacks };
+/**
+ * @module
+ * Translation Types
+ *
+ * @remarks
+ * Exports types for translation configuration and translations:
+ * - Translation configuration
+ * - Translation types
+ * - Cookie banner translations
+ * - Consent manager dialog translations
+ * - Consent manager widget translations
+ */
+export type {
+	ConsentManagerDialogTranslations,
+	ConsentManagerWidgetTranslations,
+	ConsentTypeTranslations,
+	ConsentTypesTranslations,
+	CookieBannerTranslations,
+	TranslationConfig,
+	Translations,
+} from './translations';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,MAAM,cAAc,CAAC;AAEtB,YAAY,EACX,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,GACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAE9E,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE/D,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,CAAC;AAE5C;;;;;;;;;;;GAWG;AAEH,YAAY,EACX,gCAAgC,EAChC,gCAAgC,EAChC,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACxB,iBAAiB,EACjB,YAAY,GACZ,MAAM,gBAAgB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+import * as __WEBPACK_EXTERNAL_MODULE__gdpr_js_09f2378e__ from './gdpr.js';
+var __webpack_exports__consentTypes =
+	__WEBPACK_EXTERNAL_MODULE__gdpr_js_09f2378e__.consentTypes;
+export { __webpack_exports__consentTypes as consentTypes };

package/dist/types/translations.cjs

@@ -0,0 +1,22 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/types/translations.d.ts

@@ -0,0 +1,52 @@
+import type { ConsentType } from './gdpr';
+export interface CookieBannerTranslations {
+	title: string;
+	description: string;
+	acceptAll: string;
+	rejectAll: string;
+	customize: string;
+}
+export interface ConsentManagerDialogTranslations {
+	title: string;
+	description: string;
+	save: string;
+	acceptAll: string;
+	rejectAll: string;
+	close: string;
+}
+export interface ConsentTypeTranslations {
+	title: string;
+	description: string;
+}
+export interface ConsentManagerWidgetTranslations {
+	title: string;
+	description: string;
+	save: string;
+	acceptAll: string;
+	rejectAll: string;
+}
+/**
+ * Maps consent type names to their respective translations.
+ * Uses the name property from ConsentType to ensure type safety.
+ */
+export type ConsentTypesTranslations = {
+	[key in ConsentType['name']]: ConsentTypeTranslations;
+};
+export interface CompleteTranslations {
+	cookieBanner: CookieBannerTranslations;
+	consentManagerDialog: ConsentManagerDialogTranslations;
+	consentManagerWidget: ConsentManagerWidgetTranslations;
+	consentTypes: ConsentTypesTranslations;
+}
+export interface Translations {
+	cookieBanner: Partial<CookieBannerTranslations>;
+	consentManagerDialog: Partial<ConsentManagerDialogTranslations>;
+	consentManagerWidget: Partial<ConsentManagerWidgetTranslations>;
+	consentTypes: Partial<ConsentTypesTranslations>;
+}
+export interface TranslationConfig {
+	translations: Record<string, Partial<Translations>>;
+	defaultLanguage?: string;
+	disableAutoLanguageSwitch?: boolean;
+}
+//# sourceMappingURL=translations.d.ts.map

package/dist/types/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../src/types/translations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,WAAW,wBAAwB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gCAAgC;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gCAAgC;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;KACrC,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,GAAG,uBAAuB;CACrD,CAAC;AAGF,MAAM,WAAW,oBAAoB;IACpC,YAAY,EAAE,wBAAwB,CAAC;IACvC,oBAAoB,EAAE,gCAAgC,CAAC;IACvD,oBAAoB,EAAE,gCAAgC,CAAC;IACvD,YAAY,EAAE,wBAAwB,CAAC;CACvC;AAGD,MAAM,WAAW,YAAY;IAC5B,YAAY,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAChD,oBAAoB,EAAE,OAAO,CAAC,gCAAgC,CAAC,CAAC;IAChE,oBAAoB,EAAE,OAAO,CAAC,gCAAgC,CAAC,CAAC;IAChE,YAAY,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAChD;AACD,MAAM,WAAW,iBAAiB;IACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACpC"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "c15t",
+  "version": "0.0.1-rc.3",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "browserslist": [
+    ">0.2%",
+    "not dead",
+    "not op_mini all"
+  ],
+  "dependencies": {
+    "zustand": "^5.0.3"
+  },
+  "devDependencies": {
+    "happy-dom": "^17.1.0",
+    "@c15t/typescript-config": "0.0.1-beta.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "check-types": "tsc --noEmit",
+    "dev": "rslib build --watch",
+    "fmt": "pnpm biome format --write .",
+    "lint": "pnpm biome lint ./src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/rslib.config.ts

@@ -0,0 +1,28 @@
+import { pluginReact } from '@rsbuild/plugin-react';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig({
+	source: {
+		entry: {
+			index: ['./src/**'],
+		},
+	},
+	lib: [
+		{
+			bundle: false,
+			dts: true,
+			format: 'esm',
+		},
+		{
+			bundle: false,
+			dts: true,
+			format: 'cjs',
+		},
+	],
+	output: {
+		target: 'web',
+
+		cleanDistPath: true,
+	},
+	plugins: [pluginReact()],
+});

package/src/index.ts

@@ -0,0 +1,31 @@
+// Re-export store
+export { createConsentManagerStore } from './store';
+export type { PrivacyConsentState } from './store.type';
+// Re-export all utilities
+export * from './libs/consent-utils';
+export { createTrackingBlocker } from './libs/tracking-blocker';
+export type { TrackingBlockerConfig } from './libs/tracking-blocker';
+
+// Re-export types and constants
+export { consentTypes } from './types';
+export type {
+	CallbackFunction,
+	Callbacks,
+	AllConsentNames,
+	ConsentType,
+	ConsentState,
+	ComplianceRegion,
+	ComplianceSettings,
+	PrivacySettings,
+	HasConsentedProps,
+	NamespaceProps,
+	TranslationConfig,
+	Translations,
+	CookieBannerTranslations,
+	ConsentManagerDialogTranslations,
+	ConsentManagerWidgetTranslations,
+	ConsentTypeTranslations,
+	ConsentTypesTranslations,
+} from './types';
+
+export { defaultTranslationConfig } from './translations';

package/src/libs/__tests__/tracking-blocker.test.ts

@@ -0,0 +1,271 @@
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	test,
+	vi,
+} from 'vitest';
+import { createTrackingBlocker } from '../tracking-blocker';
+
+const BLOCKED_CONSENT = {
+	experience: false,
+	functionality: false,
+	marketing: false,
+	measurement: false,
+	necessary: true,
+};
+
+const ALLOWED_CONSENT = {
+	...BLOCKED_CONSENT,
+	measurement: true,
+};
+
+describe('TrackingBlocker', () => {
+	// Store original globals
+	const originalFetch = global.fetch;
+	const originalXHR = global.XMLHttpRequest;
+
+	// Set up test environment before all tests
+	beforeAll(() => {
+		// Mock fetch to simulate a successful response
+		global.fetch = vi
+			.fn()
+			.mockImplementation(() => Promise.resolve(new Response()));
+
+		// We'll use the real XMLHttpRequest instead of mocking it
+		if (!global.XMLHttpRequest) {
+			global.XMLHttpRequest = originalXHR;
+		}
+	});
+
+	// Clean up test environment after all tests
+	afterAll(() => {
+		// Restore globals
+		global.fetch = originalFetch;
+		global.XMLHttpRequest = originalXHR;
+	});
+
+	beforeEach(() => {
+		// Reset all mocks and spies
+		vi.clearAllMocks();
+		vi.restoreAllMocks();
+
+		// Reset fetch to a fresh mock for each test
+		global.fetch = vi
+			.fn()
+			.mockImplementation(() => Promise.resolve(new Response()));
+		window.fetch = global.fetch;
+
+		// Reset XMLHttpRequest to original
+		window.XMLHttpRequest = originalXHR;
+
+		// Mock document.dispatchEvent since it's not included in the global setup
+		vi.spyOn(document, 'dispatchEvent');
+	});
+
+	test('blocks fetch requests to tracking domains when consent not granted', async () => {
+		// Create tracking blocker with default consents (all false except necessary)
+		const trackingBlocker = createTrackingBlocker({}, BLOCKED_CONSENT);
+
+		// Try to fetch from a tracking domain (Google Analytics)
+		await expect(
+			fetch('https://www.google-analytics.com/analytics.js')
+		).rejects.toThrow(
+			'Request to https://www.google-analytics.com/analytics.js blocked due to missing consent'
+		);
+
+		// Verify blocked event was dispatched
+		expect(document.dispatchEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				type: 'ConsentBlockedRequest',
+				detail: {
+					url: 'https://www.google-analytics.com/analytics.js',
+				},
+			})
+		);
+	});
+
+	test('blocks XMLHttpRequest to tracking domains when consent not granted', () => {
+		// Create tracking blocker with default consents
+		const trackingBlocker = createTrackingBlocker({}, BLOCKED_CONSENT);
+		// Create new XMLHttpRequest
+		const xhr = new XMLHttpRequest();
+
+		// Try to open request to tracking domain
+		expect(() => {
+			xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+		}).toThrow(
+			'Request to https://www.google-analytics.com/analytics.js blocked due to missing consent'
+		);
+
+		// Verify blocked event was dispatched
+		expect(document.dispatchEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				type: 'ConsentBlockedRequest',
+				detail: {
+					url: 'https://www.google-analytics.com/analytics.js',
+				},
+			})
+		);
+	});
+
+	test('allows fetch requests to tracking domains after consent granted', async () => {
+		// Reset fetch to ensure we start with a clean state
+		window.fetch = global.fetch;
+
+		// Create tracking blocker with consent granted
+		const trackingBlocker = createTrackingBlocker({}, ALLOWED_CONSENT);
+
+		// Create a spy on window.fetch after tracking blocker has overridden it
+		const fetchSpy = vi.spyOn(window, 'fetch');
+
+		// Try fetch request - should now be allowed
+		await fetch('https://www.google-analytics.com/analytics.js');
+
+		// Verify fetch was called with correct URL
+		expect(fetchSpy).toHaveBeenCalledWith(
+			'https://www.google-analytics.com/analytics.js'
+		);
+
+		// Clean up
+		trackingBlocker.destroy();
+	});
+
+	test('allows XMLHttpRequest to tracking domains after consent granted', () => {
+		// Create tracking blocker with default consents
+		const trackingBlocker = createTrackingBlocker({}, ALLOWED_CONSENT);
+
+		// Create new XMLHttpRequest
+		const xhr = new XMLHttpRequest();
+
+		// Should not throw error now that consent is granted
+		expect(() => {
+			xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+		}).not.toThrow();
+	});
+
+	test('allows requests to non-tracking domains regardless of consent', async () => {
+		const trackingBlocker = createTrackingBlocker({}, BLOCKED_CONSENT);
+
+		// Try fetch to non-tracking domain
+		const fetchSpy = vi.spyOn(window, 'fetch');
+		await fetch('https://api.example.com/data');
+		expect(fetchSpy).toHaveBeenCalledWith('https://api.example.com/data');
+
+		// Try XMLHttpRequest to non-tracking domain
+		const xhr = new XMLHttpRequest();
+		expect(() => {
+			xhr.open('GET', 'https://api.example.com/data');
+		}).not.toThrow();
+	});
+
+	test('handles custom domain consent map', async () => {
+		// Create tracking blocker with custom domain map
+		const trackingBlocker = createTrackingBlocker(
+			{
+				overrideDomainConsentMap: true,
+				domainConsentMap: {
+					'custom-analytics.example.com': 'measurement',
+				},
+			},
+			BLOCKED_CONSENT
+		);
+
+		// Should block request to custom domain
+		await expect(
+			fetch('https://custom-analytics.example.com/track')
+		).rejects.toThrow(
+			'Request to https://custom-analytics.example.com/track blocked due to missing consent'
+		);
+
+		// Update consent
+		trackingBlocker.updateConsents({
+			experience: false,
+			functionality: false,
+			marketing: false,
+			measurement: true,
+			necessary: true,
+		});
+		const fetchSpy = vi.spyOn(window, 'fetch');
+
+		// Should now allow request
+		await fetch('https://custom-analytics.example.com/track');
+		expect(fetchSpy).toHaveBeenCalledWith(
+			'https://custom-analytics.example.com/track'
+		);
+	});
+
+	test('handles subdomains correctly', async () => {
+		const trackingBlocker = createTrackingBlocker({}, BLOCKED_CONSENT);
+
+		// Should block request to subdomain of google-analytics.com
+		await expect(
+			fetch('https://subdomain.google-analytics.com/track')
+		).rejects.toThrow(
+			'Request to https://subdomain.google-analytics.com/track blocked due to missing consent'
+		);
+	});
+
+	test('can be disabled via config', async () => {
+		// Create tracking blocker with automatic blocking disabled
+		const trackingBlocker = createTrackingBlocker(
+			{
+				disableAutomaticBlocking: true,
+			},
+			BLOCKED_CONSENT
+		);
+
+		// Should allow all requests regardless of consent
+		await fetch('https://www.google-analytics.com/analytics.js');
+		expect(fetch).toHaveBeenCalledWith(
+			'https://www.google-analytics.com/analytics.js'
+		);
+	});
+
+	test('cleanup restores original fetch and XMLHttpRequest functionality', async () => {
+		// Create tracking blocker which should wrap the implementations
+		const trackingBlocker = createTrackingBlocker({}, BLOCKED_CONSENT);
+
+		// Verify tracking is active by trying a blocked request
+		await expect(
+			fetch('https://www.google-analytics.com/analytics.js')
+		).rejects.toThrow();
+
+		// Destroy tracking blocker
+		trackingBlocker.destroy();
+
+		// After cleanup, the blocked request should work
+		await fetch('https://www.google-analytics.com/analytics.js');
+		expect(fetch).toHaveBeenCalledWith(
+			'https://www.google-analytics.com/analytics.js'
+		);
+
+		// Verify XMLHttpRequest also works after cleanup
+		const xhr = new XMLHttpRequest();
+		expect(() => {
+			xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+		}).not.toThrow();
+	});
+
+	test('handles multiple concurrent requests correctly', async () => {
+		createTrackingBlocker({}, BLOCKED_CONSENT);
+
+		// Create multiple concurrent requests
+		const requests = Promise.all([
+			expect(
+				fetch('https://www.google-analytics.com/analytics.js')
+			).rejects.toThrow(),
+			expect(
+				fetch('https://www.google-analytics.com/collect')
+			).rejects.toThrow(),
+			fetch('https://api.example.com/data'), // Should succeed
+		]);
+		await requests;
+
+		// Verify correct number of blocked events
+		// 6 blocked events for the 3 requests due to retries
+		expect(document.dispatchEvent).toHaveBeenCalledTimes(6);
+	});
+});