@prosopo/procaptcha-common 2.9.23 → 2.10.18

package/src/tests/providers.test.ts

@@ -0,0 +1,175 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	getProcaptchaRandomActiveProvider,
+	providerRetry,
+} from "../providers.js";
+
+// Mock the load-balancer module
+vi.mock("@prosopo/load-balancer", () => ({
+	getRandomActiveProvider: vi.fn(),
+}));
+
+describe("providers", () => {
+	describe("getProcaptchaRandomActiveProvider", () => {
+		// biome-ignore lint/suspicious/noExplicitAny: Store original crypto function
+		let originalGetRandomValues: any;
+
+		beforeEach(() => {
+			originalGetRandomValues = global.window.crypto.getRandomValues.bind(
+				global.window.crypto,
+			);
+		});
+
+		afterEach(() => {
+			global.window.crypto.getRandomValues = originalGetRandomValues;
+		});
+
+		it("should generate random values and call getRandomActiveProvider", async () => {
+			// Mock window.crypto.getRandomValues
+			const mockRandomValues = new Uint8Array([
+				10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+			]);
+			const mockGetRandomValues = vi.fn(() => mockRandomValues);
+			// biome-ignore lint/suspicious/noExplicitAny: Mock crypto API
+			global.window.crypto.getRandomValues = mockGetRandomValues as any;
+
+			// Mock the getRandomActiveProvider import
+			const { getRandomActiveProvider } = await import(
+				"@prosopo/load-balancer"
+			);
+			vi.mocked(getRandomActiveProvider).mockResolvedValue({
+				providerUrl: "https://test-provider.com",
+				// biome-ignore lint/suspicious/noExplicitAny: Mock return type
+			} as any);
+
+			const result = await getProcaptchaRandomActiveProvider("development");
+
+			expect(mockGetRandomValues).toHaveBeenCalledWith(expect.any(Uint8Array));
+			expect(getRandomActiveProvider).toHaveBeenCalledWith("development", 550); // sum of mockRandomValues
+			expect(result).toEqual({ providerUrl: "https://test-provider.com" });
+		});
+
+		it("should use different random values on each call", async () => {
+			let callCount = 0;
+			const mockGetRandomValues = vi.fn((arr: Uint8Array) => {
+				callCount++;
+				arr.fill(callCount);
+				return arr;
+			});
+			// biome-ignore lint/suspicious/noExplicitAny: Mock crypto API
+			global.window.crypto.getRandomValues = mockGetRandomValues as any;
+
+			const { getRandomActiveProvider } = await import(
+				"@prosopo/load-balancer"
+			);
+			// biome-ignore lint/suspicious/noExplicitAny: Mock return type
+			vi.mocked(getRandomActiveProvider).mockResolvedValue({} as any);
+
+			await getProcaptchaRandomActiveProvider("development");
+			await getProcaptchaRandomActiveProvider("development");
+
+			expect(mockGetRandomValues).toHaveBeenCalledTimes(2);
+		});
+	});
+
+	describe("providerRetry", () => {
+		it("should successfully execute currentFn without retrying", async () => {
+			const currentFn = vi.fn().mockResolvedValue(undefined);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+
+			await providerRetry(currentFn, retryFn, stateReset, 0, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+			expect(stateReset).not.toHaveBeenCalled();
+		});
+
+		it("should call retryFn when currentFn fails and attempts are below max", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn().mockResolvedValue(undefined);
+			const stateReset = vi.fn();
+
+			await providerRetry(currentFn, retryFn, stateReset, 1, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).toHaveBeenCalledTimes(1);
+		});
+
+		it("should call stateReset and not retry when max retries reached", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await providerRetry(currentFn, retryFn, stateReset, 3, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+			expect(consoleErrorSpy).toHaveBeenCalledWith(error);
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Max retries (3 of 3) reached, aborting",
+			);
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("should call stateReset and not retry when attempts exceed max", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await providerRetry(currentFn, retryFn, stateReset, 5, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("should reset state even when retryFn fails", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn().mockRejectedValue(new Error("Retry failed"));
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await expect(
+				providerRetry(currentFn, retryFn, stateReset, 1, 3),
+			).rejects.toThrow("Retry failed");
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).toHaveBeenCalledTimes(1);
+
+			consoleErrorSpy.mockRestore();
+		});
+	});
+});

package/src/tests/state-builder.test.ts

@@ -0,0 +1,264 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type { ProcaptchaState } from "@prosopo/types";
+import { describe, expect, it, vi } from "vitest";
+import { buildUpdateState, useProcaptcha } from "../state/builder.js";
+
+describe("state/builder", () => {
+	describe("buildUpdateState", () => {
+		it("should mutate state and call onStateUpdate with partial state", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			const partialState = { isHuman: true, attemptCount: 1 };
+			updateState(partialState);
+
+			expect(state.isHuman).toBe(true);
+			expect(state.attemptCount).toBe(1);
+			expect(onStateUpdate).toHaveBeenCalledWith(partialState);
+		});
+
+		it("should handle multiple property updates in order", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			updateState({ loading: true, index: 5, showModal: true });
+
+			expect(state.loading).toBe(true);
+			expect(state.index).toBe(5);
+			expect(state.showModal).toBe(true);
+		});
+
+		it("should update error state correctly", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			const errorObj = { message: "Test error", key: "test" };
+			updateState({ error: errorObj });
+
+			expect(state.error).toEqual(errorObj);
+			expect(onStateUpdate).toHaveBeenCalledWith({ error: errorObj });
+		});
+	});
+
+	describe("useProcaptcha", () => {
+		it("should initialize with default state values", () => {
+			const useState = vi.fn((defaultValue) => [defaultValue, vi.fn()]);
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			expect(state.isHuman).toBe(false);
+			expect(state.index).toBe(0);
+			expect(state.solutions).toEqual([]);
+			expect(state.showModal).toBe(false);
+			expect(state.loading).toBe(false);
+			expect(state.sendData).toBe(false);
+			expect(state.attemptCount).toBe(0);
+			expect(state.account).toBeUndefined();
+			expect(state.captchaApi).toBeUndefined();
+			expect(state.challenge).toBeUndefined();
+			expect(state.error).toBeUndefined();
+			expect(typeof updateFn).toBe("function");
+		});
+
+		it("should call appropriate setters when updating state", () => {
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter functions
+			const setters: Record<string, any> = {};
+
+			const useState = vi.fn((defaultValue) => {
+				// Create a unique key based on the type and value to track different state variables
+				const key =
+					typeof defaultValue === "boolean"
+						? `boolean-${defaultValue}`
+						: typeof defaultValue === "number"
+							? `number-${defaultValue}`
+							: Array.isArray(defaultValue)
+								? "array"
+								: "other";
+
+				if (!setters[key]) {
+					setters[key] = vi.fn();
+				}
+				return [defaultValue, setters[key]];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			updateFn({
+				isHuman: true,
+				index: 5,
+				loading: true,
+				attemptCount: 3,
+			});
+
+			// Check that setters were called
+			// isHuman setter (boolean-false)
+			expect(setters["boolean-false"]).toHaveBeenCalledWith(true);
+			// index and attemptCount setters (both number-0)
+			expect(setters["number-0"]).toHaveBeenCalledWith(5);
+			expect(setters["number-0"]).toHaveBeenCalledWith(3);
+		});
+
+		it("should handle solutions array correctly with slice", () => {
+			const setSolutions = vi.fn();
+			// biome-ignore lint/suspicious/noExplicitAny: Mock solutions array
+			let solutionsValue: any[] = [];
+
+			const useState = vi.fn((defaultValue) => {
+				if (Array.isArray(defaultValue)) {
+					return [
+						solutionsValue,
+						// biome-ignore lint/suspicious/noExplicitAny: Mock setter function
+						(newValue: any) => {
+							solutionsValue = newValue;
+							setSolutions(newValue);
+						},
+					];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			const newSolutions: [string, number, number][][] = [[["test", 1, 2]]];
+			updateFn({ solutions: newSolutions });
+
+			expect(setSolutions).toHaveBeenCalled();
+			// Verify that slice was called by checking that we got a new array reference
+			const callArg = setSolutions.mock.calls[0]?.[0];
+			expect(callArg).toBeDefined();
+			expect(callArg).not.toBe(newSolutions);
+			expect(callArg).toEqual(newSolutions);
+		});
+
+		it("should not call setters for undefined values in partial update", () => {
+			const setIsHuman = vi.fn();
+			const setIndex = vi.fn();
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter tracking
+			let isHumanSetter: any;
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter tracking
+			let indexSetter: any;
+
+			const useState = vi.fn((defaultValue) => {
+				if (defaultValue === false) {
+					isHumanSetter = setIsHuman;
+					return [false, setIsHuman];
+				}
+				if (defaultValue === 0) {
+					indexSetter = setIndex;
+					return [0, setIndex];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			updateFn({ isHuman: true });
+
+			expect(setIsHuman).toHaveBeenCalledWith(true);
+			expect(setIndex).not.toHaveBeenCalled();
+		});
+
+		it("should handle error state update", () => {
+			const setError = vi.fn();
+
+			const useState = vi.fn((defaultValue) => {
+				if (defaultValue === undefined && setError.mock.calls.length === 0) {
+					return [undefined, setError];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			const errorObj = { message: "Test error", key: "testKey" };
+			updateFn({ error: errorObj });
+
+			expect(setError).toHaveBeenCalledWith(errorObj);
+		});
+	});
+});

package/src/tests/window.test.ts

@@ -0,0 +1,137 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	getWindowCallback,
+	isSecureBrowserContext,
+} from "../elements/window.js";
+
+describe("elements/window", () => {
+	describe("getWindowCallback", () => {
+		const originalWindow = global.window;
+
+		afterEach(() => {
+			// Clean up window object
+			const keys = Object.keys(window);
+			for (const key of keys) {
+				if (key.startsWith("test")) {
+					// biome-ignore lint/suspicious/noExplicitAny: Dynamic property cleanup
+					delete (window as any)[key];
+				}
+			}
+		});
+
+		it("should retrieve a function from window object", () => {
+			const testFn = () => "test";
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testCallback = testFn;
+
+			const result = getWindowCallback("testCallback");
+			expect(result).toBe(testFn);
+		});
+
+		it("should handle window. prefix in callback name", () => {
+			const testFn = () => "test";
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testCallback = testFn;
+
+			const result = getWindowCallback("window.testCallback");
+			expect(result).toBe(testFn);
+		});
+
+		it("should throw error if callback is not a function", () => {
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testCallback = "not a function";
+
+			expect(() => getWindowCallback("testCallback")).toThrow(
+				"Callback testCallback is not defined on the window object",
+			);
+		});
+
+		it("should throw error if callback does not exist", () => {
+			expect(() => getWindowCallback("nonExistentCallback")).toThrow(
+				"Callback nonExistentCallback is not defined on the window object",
+			);
+		});
+
+		it("should handle callback that is undefined", () => {
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testCallback = undefined;
+
+			expect(() => getWindowCallback("testCallback")).toThrow(
+				"Callback testCallback is not defined on the window object",
+			);
+		});
+
+		it("should handle callback that is null", () => {
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testCallback = null;
+
+			expect(() => getWindowCallback("testCallback")).toThrow(
+				"Callback testCallback is not defined on the window object",
+			);
+		});
+
+		it("should work with arrow functions", () => {
+			const arrowFn = (x: number) => x * 2;
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testArrowCallback = arrowFn;
+
+			const result = getWindowCallback("testArrowCallback");
+			expect(result).toBe(arrowFn);
+			expect(result(5)).toBe(10);
+		});
+
+		it("should work with regular functions", () => {
+			function regularFn(x: number) {
+				return x * 2;
+			}
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).testRegularCallback = regularFn;
+
+			const result = getWindowCallback("testRegularCallback");
+			expect(result).toBe(regularFn);
+			expect(result(5)).toBe(10);
+		});
+	});
+
+	describe("isSecureBrowserContext", () => {
+		const originalIsSecureContext = window.isSecureContext;
+
+		const setIsSecureContext = (value: boolean): void => {
+			Object.defineProperty(window, "isSecureContext", {
+				value,
+				configurable: true,
+				writable: true,
+			});
+		};
+
+		afterEach(() => {
+			setIsSecureContext(originalIsSecureContext);
+		});
+
+		it("should return true in a secure context (HTTPS/localhost)", () => {
+			setIsSecureContext(true);
+
+			expect(isSecureBrowserContext()).toBe(true);
+		});
+
+		it("should return false in an insecure context (plain HTTP)", () => {
+			setIsSecureContext(false);
+
+			expect(isSecureBrowserContext()).toBe(false);
+		});
+	});
+});

package/tsconfig.cjs.json

@@ -0,0 +1,32 @@
+{
+	"extends": "../../tsconfig.cjs.json",
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist/cjs",
+		"lib": ["es6", "dom"],
+		"jsxImportSource": "@emotion/react"
+	},
+	"include": [
+		"./src/**/*.ts",
+		"./src/**/*.json",
+		"./src/**/*.d.ts",
+		"./src/**/*.tsx"
+	],
+	"references": [
+		{
+			"path": "../../dev/config/tsconfig.cjs.json"
+		},
+		{
+			"path": "../load-balancer/tsconfig.cjs.json"
+		},
+		{
+			"path": "../types/tsconfig.cjs.json"
+		},
+		{
+			"path": "../widget-skeleton/tsconfig.cjs.json"
+		},
+		{
+			"path": "../account/tsconfig.cjs.json"
+		}
+	]
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+	"extends": "../../tsconfig.esm.json",
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"lib": ["es6", "dom"],
+		"jsxImportSource": "@emotion/react"
+	},
+	"include": [
+		"src",
+		"src/**/*.json",
+		"src/**/*.ts",
+		"src/**/*.tsx",
+		"src/**/*.d.ts"
+	],
+	"references": [
+		{
+			"path": "../../dev/config/tsconfig.json"
+		},
+		{
+			"path": "../load-balancer"
+		},
+		{
+			"path": "../types"
+		},
+		{
+			"path": "../widget-skeleton"
+		},
+		{
+			"path": "../account"
+		}
+	]
+}