@prosopo/procaptcha-puzzle 2.14.6 → 2.15.0

package/src/tests/managerHarness.ts

@@ -1,169 +0,0 @@
-// 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 {
-	Account,
-	FrictionlessState,
-	GetPuzzleCaptchaResponse,
-	MouseMovementPoint,
-	ProcaptchaCallbacks,
-	ProcaptchaClientConfigInput,
-	ProcaptchaState,
-	PuzzleCaptchaSolutionResponse,
-	PuzzleEvent,
-	RandomProvider,
-} from "@prosopo/types";
-import { vi } from "vitest";
-
-/**
- * Shared fixtures for the puzzle suites. Kept out of the test files so the mock
- * factories, which vitest hoists above every import, can build their canned
- * responses from the same shapes the assertions use.
- */
-
-export const PROVIDER_URL = "https://provider.one";
-export const OTHER_PROVIDER_URL = "https://provider.two";
-export const USER_ADDRESS = "user-address";
-export const SITE_KEY = "site-key";
-
-export const config = (
-	overrides: Partial<ProcaptchaClientConfigInput> = {},
-): ProcaptchaClientConfigInput => ({
-	account: { address: SITE_KEY },
-	defaultEnvironment: "production",
-	...overrides,
-});
-
-export const state = (
-	overrides: Partial<ProcaptchaState> = {},
-): ProcaptchaState => ({
-	isHuman: false,
-	index: 0,
-	solutions: [],
-	captchaApi: undefined,
-	challenge: undefined,
-	showModal: false,
-	loading: false,
-	account: undefined,
-	dappAccount: undefined,
-	submission: undefined,
-	timeout: undefined,
-	successfullChallengeTimeout: undefined,
-	sendData: false,
-	attemptCount: 0,
-	error: undefined,
-	sessionId: undefined,
-	...overrides,
-});
-
-export type SignRaw = NonNullable<
-	NonNullable<Account["extension"]>["signer"]["signRaw"]
->;
-
-/**
- * An account carrying just enough of an injected extension to sign: the rest of
- * the interface is never touched by the manager, but the type demands it.
- */
-export const account = (signRaw?: SignRaw): Account => ({
-	account: { address: USER_ADDRESS },
-	extension: {
-		name: "test-extension",
-		version: "0.0.0",
-		accounts: {
-			get: async () => [{ address: USER_ADDRESS }],
-			subscribe: () => () => undefined,
-		},
-		signer: signRaw ? { signRaw } : {},
-	},
-});
-
-export const accountWithoutExtension = (): Account => ({
-	account: { address: USER_ADDRESS },
-});
-
-export const randomProvider = (url: string = PROVIDER_URL): RandomProvider => ({
-	providerAccount: "provider-account",
-	provider: { url },
-});
-
-export const challengeResponse = (
-	overrides: Partial<GetPuzzleCaptchaResponse> = {},
-): GetPuzzleCaptchaResponse => ({
-	challenge: "0x1___0xdeadbeef___1700000000000",
-	background: "data:image/webp;base64,UklGRg==",
-	piece: "data:image/webp;base64,UklGRg==",
-	pieceSize: 44,
-	originX: 20,
-	originY: 100,
-	timestamp: "1700000000000",
-	signature: { provider: { challenge: "0xprovider-challenge" } },
-	status: "ok",
-	...overrides,
-});
-
-export const solutionResponse = (
-	overrides: Partial<PuzzleCaptchaSolutionResponse> = {},
-): PuzzleCaptchaSolutionResponse => ({
-	verified: true,
-	status: "ok",
-	...overrides,
-});
-
-export const puzzleEvents = (): PuzzleEvent[] => [
-	{ x: 20, y: 100, t: 0 },
-	{ x: 120, y: 90, t: 120 },
-	{ x: 200, y: 80, t: 260 },
-];
-
-export const callbacks = (
-	overrides: Partial<ProcaptchaCallbacks> = {},
-): ProcaptchaCallbacks => ({ ...overrides });
-
-/**
- * The signer every fixture account uses, so a test can assert on what the
- * manager asked the extension to sign without rebuilding the frictionless
- * state it was handed.
- */
-export const signRawMock = vi.fn<SignRaw>();
-
-export const frictionless = (
-	overrides: Partial<FrictionlessState> = {},
-): FrictionlessState => ({
-	provider: randomProvider(),
-	userAccount: account(signRawMock),
-	restart: () => undefined,
-	...overrides,
-});
-
-/**
- * A behaviour collector holding a fixed set of points. The manager only ever
- * calls `getData`, but the type demands the whole lifecycle, so the rest are
- * stubs rather than omissions.
- */
-export const collector = (
-	points: MouseMovementPoint[],
-): NonNullable<FrictionlessState["behaviorCollector1"]> => ({
-	start: () => undefined,
-	stop: () => undefined,
-	getData: () => points,
-	clear: () => undefined,
-});
-
-/**
- * jsdom's setTimeout hands back a plain number while the shared state types the
- * handle as Node's Timeout, so tests that seed a pending timer have to bridge
- * the two. The value the manager passes to clearTimeout is the number itself.
- */
-export const timerHandle = (id: number): ReturnType<typeof setTimeout> =>
-	id as unknown as ReturnType<typeof setTimeout>;

package/src/tests/procaptchaPuzzle.test-d.ts

@@ -1,212 +0,0 @@
-// 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 { Ti18n, Translator } from "@prosopo/locale";
-import type {
-	FrictionlessState,
-	GetPuzzleCaptchaResponse,
-	ProcaptchaCallbacks,
-	ProcaptchaClientConfigInput,
-	ProcaptchaProps,
-	ProcaptchaState,
-	ProcaptchaStateUpdateFn,
-	PuzzleEvent,
-} from "@prosopo/types";
-import { lightTheme } from "@prosopo/widget-skeleton";
-import { assertType, describe, expectTypeOf, test } from "vitest";
-import {
-	type PuzzleCanvasProps,
-	mountPuzzleCanvas,
-} from "../components/puzzleCanvas.js";
-import type * as entrypoint from "../index.js";
-import { mountProcaptchaPuzzle } from "../index.js";
-import { Manager } from "../services/Manager.js";
-import {
-	challengeResponse,
-	config,
-	frictionless,
-	puzzleEvents,
-	state,
-} from "./managerHarness.js";
-
-/** The widget only ever reads `language`/`changeLanguage` off this. */
-const i18n = (): Ti18n => undefined as unknown as Ti18n;
-
-describe("the package entrypoint's types", () => {
-	test("mountProcaptchaPuzzle takes a host element and the shared widget props", () => {
-		expectTypeOf(mountProcaptchaPuzzle).parameters.toEqualTypeOf<
-			[HTMLElement, ProcaptchaProps]
-		>();
-		expectTypeOf(mountProcaptchaPuzzle).returns.toExtend<{
-			destroy: () => void;
-		}>();
-	});
-
-	test("the entrypoint exposes the lazy wrapper and the widget itself", () => {
-		// The lazy wrapper is what works without a code-splitting bundler; the
-		// direct mount is what ProcaptchaFrictionless imports once it has already
-		// paid for the dynamic import of this package.
-		expectTypeOf<keyof typeof entrypoint>().toEqualTypeOf<
-			| "mountProcaptchaPuzzle"
-			| "loadProcaptchaPuzzle"
-			| "mountProcaptchaPuzzleWidget"
-			| "mountPuzzleCanvas"
-		>();
-	});
-
-	test("config, callbacks and i18n are all required", () => {
-		// @ts-expect-error - a widget with no config has no provider to talk to.
-		assertType<ProcaptchaProps>({ callbacks: {}, i18n: i18n() });
-		// @ts-expect-error - callbacks decide what a solve reports back.
-		assertType<ProcaptchaProps>({ config: config(), i18n: i18n() });
-		assertType<ProcaptchaProps>({
-			config: config(),
-			callbacks: {},
-			i18n: i18n(),
-		});
-	});
-});
-
-describe("Manager's types", () => {
-	const updateState: ProcaptchaStateUpdateFn = () => undefined;
-	const callbacks: ProcaptchaCallbacks = {};
-
-	test("only the first four arguments are required", () => {
-		assertType<ReturnType<typeof Manager>>(
-			Manager(config(), state(), updateState, callbacks),
-		);
-		// @ts-expect-error - callbacks decide what a solve reports back.
-		Manager(config(), state(), updateState);
-	});
-
-	test("the optional arguments keep their positions", () => {
-		expectTypeOf(Manager)
-			.parameter(4)
-			.toEqualTypeOf<FrictionlessState | undefined>();
-		expectTypeOf(Manager)
-			.parameter(5)
-			.toEqualTypeOf<(() => string | undefined) | undefined>();
-	});
-
-	test("it exposes exactly start, submitSolution and resetState", () => {
-		expectTypeOf<keyof ReturnType<typeof Manager>>().toEqualTypeOf<
-			"start" | "submitSolution" | "resetState"
-		>();
-	});
-
-	test("start hands back the challenge the canvas needs to draw", () => {
-		// Unlike the POW manager, which reports only through state, the puzzle
-		// manager returns the challenge — the widget cannot render a board
-		// without the origin/target coordinates.
-		expectTypeOf<ReturnType<typeof Manager>["start"]>().toEqualTypeOf<
-			(x?: number, y?: number) => Promise<GetPuzzleCaptchaResponse | undefined>
-		>();
-	});
-
-	test("submitSolution takes the drop point and the full event trail", () => {
-		expectTypeOf<
-			Parameters<ReturnType<typeof Manager>["submitSolution"]>
-		>().toEqualTypeOf<
-			[finalX: number, finalY: number, events: PuzzleEvent[]]
-		>();
-		expectTypeOf<
-			ReturnType<ReturnType<typeof Manager>["submitSolution"]>
-		>().toEqualTypeOf<Promise<boolean>>();
-	});
-
-	test("resetState takes the frictionless restart callback and nothing else", () => {
-		expectTypeOf<
-			Parameters<ReturnType<typeof Manager>["resetState"]>
-		>().toEqualTypeOf<[frictionlessRestart?: (() => void) | undefined]>();
-		expectTypeOf<
-			ReturnType<ReturnType<typeof Manager>["resetState"]>
-		>().toEqualTypeOf<void>();
-	});
-
-	test("coordinates come off DOM events, so they are numbers", () => {
-		const manager: ReturnType<typeof Manager> = Manager(
-			config(),
-			state(),
-			updateState,
-			callbacks,
-			frictionless(),
-		);
-		// @ts-expect-error - never strings, whatever the DOM stringifies to.
-		manager.start("1", "2");
-		// @ts-expect-error - the trail is required; an empty drag still sends [].
-		manager.submitSolution(1, 2);
-	});
-});
-
-describe("PuzzleCanvas' types", () => {
-	const translator = (): Translator => undefined as unknown as Translator;
-	const onComplete = (
-		_finalX: number,
-		_finalY: number,
-		_events: PuzzleEvent[],
-	): void => undefined;
-
-	test("every prop is required, since none has a sensible default", () => {
-		// @ts-expect-error - a board with no imagery cannot be rendered.
-		mountPuzzleCanvas({ originX: 0, originY: 0 });
-		// @ts-expect-error - `submitting` gates the drag; omitting it unlocks it.
-		mountPuzzleCanvas({
-			originX: 0,
-			originY: 0,
-			background: "data:image/webp;base64,UklGRg==",
-			piece: "data:image/webp;base64,UklGRg==",
-			pieceSize: 44,
-			onComplete,
-			showRetry: false,
-			theme: lightTheme,
-			translator: translator(),
-		});
-	});
-
-	test("the full prop set mounts a component that can be updated and torn down", () => {
-		expectTypeOf(
-			mountPuzzleCanvas({
-				originX: 0,
-				originY: 0,
-				background: "data:image/webp;base64,UklGRg==",
-				piece: "data:image/webp;base64,UklGRg==",
-				pieceSize: 44,
-				onComplete,
-				showRetry: false,
-				submitting: false,
-				theme: lightTheme,
-				translator: translator(),
-			}),
-		).toExtend<{
-			update: (props: PuzzleCanvasProps) => void;
-			destroy: () => void;
-		}>();
-	});
-
-	test("the drop is reported synchronously, not as a promise", () => {
-		// The widget's own handler is async, but the canvas must not await it:
-		// a returned promise here would be dropped on the floor.
-		expectTypeOf(onComplete).returns.toEqualTypeOf<void>();
-	});
-});
-
-describe("the harness fixtures match the shared types", () => {
-	test("they build the real shapes, not lookalikes", () => {
-		expectTypeOf(config()).toEqualTypeOf<ProcaptchaClientConfigInput>();
-		expectTypeOf(state()).toEqualTypeOf<ProcaptchaState>();
-		expectTypeOf(frictionless()).toEqualTypeOf<FrictionlessState>();
-		expectTypeOf(challengeResponse()).toEqualTypeOf<GetPuzzleCaptchaResponse>();
-		expectTypeOf(puzzleEvents()).toEqualTypeOf<PuzzleEvent[]>();
-	});
-});

package/src/tests/procaptchaPuzzle.unit.test.ts

@@ -1,138 +0,0 @@
-// 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 { Ti18n } from "@prosopo/locale";
-import type { ProcaptchaProps } from "@prosopo/types";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import type { ProcaptchaPuzzleHandle } from "../components/procaptchaWidget.js";
-import * as entrypoint from "../index.js";
-import { type Mounted, mount, settle } from "./domHarness.js";
-import { config } from "./managerHarness.js";
-
-/**
- * The outer entry point exists only to lazy-load the widget and hand it the
- * props it was given, so what is worth pinning down is that nothing is dropped
- * on the way through — a wrapper that names props one at a time silently loses
- * the ones added later.
- */
-const mocks = vi.hoisted(() => ({
-	received: [] as ProcaptchaProps[],
-	destroyed: { count: 0 },
-}));
-
-vi.mock("../components/procaptchaWidget.js", () => ({
-	mountProcaptchaPuzzleWidget: (
-		container: HTMLElement,
-		props: ProcaptchaProps,
-	): ProcaptchaPuzzleHandle => {
-		mocks.received.push(props);
-		const element = document.createElement("div");
-		element.setAttribute("data-testid", "widget");
-		container.appendChild(element);
-		return {
-			destroy: () => {
-				element.remove();
-				mocks.destroyed.count += 1;
-			},
-		};
-	},
-}));
-
-let mounted: Mounted;
-let widget: ProcaptchaPuzzleHandle | undefined;
-
-const props = (overrides: Partial<ProcaptchaProps> = {}): ProcaptchaProps => ({
-	config: config(),
-	callbacks: {},
-	i18n: undefined as unknown as Ti18n,
-	...overrides,
-});
-
-const render = async (widgetProps: ProcaptchaProps): Promise<void> => {
-	widget = entrypoint.mountProcaptchaPuzzle(mounted.container, widgetProps);
-	await settle();
-};
-
-beforeEach(() => {
-	mocks.received.length = 0;
-	mocks.destroyed.count = 0;
-	widget = undefined;
-	mounted = mount();
-});
-
-afterEach(() => {
-	widget?.destroy();
-	widget = undefined;
-	mounted.unmount();
-});
-
-describe("mountProcaptchaPuzzle", () => {
-	test("renders the widget once it has loaded", async () => {
-		await render(props());
-		expect(
-			mounted.container.querySelector('[data-testid="widget"]'),
-		).not.toBeNull();
-	});
-
-	test("passes on the props the widget needs but never names", async () => {
-		const onSessionInvalidated = vi.fn<(x?: number, y?: number) => void>();
-		await render(
-			props({
-				autoStart: true,
-				startCoords: { x: 1, y: 2 },
-				onSessionInvalidated,
-			}),
-		);
-		expect(mocks.received[0]).toMatchObject({
-			autoStart: true,
-			startCoords: { x: 1, y: 2 },
-			onSessionInvalidated,
-		});
-	});
-
-	test("passes on the props it does name, too", async () => {
-		const callbacks = { onHuman: vi.fn<(token: string) => void>() };
-		await render(props({ callbacks }));
-		expect(mocks.received[0]?.callbacks).toBe(callbacks);
-		expect(mocks.received[0]?.config).toEqual(config());
-	});
-
-	test("tears the loaded widget down", async () => {
-		await render(props());
-		widget?.destroy();
-		widget = undefined;
-		expect(mocks.destroyed.count).toBe(1);
-		expect(
-			mounted.container.querySelector('[data-testid="widget"]'),
-		).toBeNull();
-	});
-
-	test("cancels a mount that is still loading", async () => {
-		// Otherwise a widget torn down mid-load reappears as an orphan that
-		// nothing holds a handle to.
-		widget = entrypoint.mountProcaptchaPuzzle(mounted.container, props());
-		widget.destroy();
-		widget = undefined;
-		await settle();
-		expect(mocks.received).toHaveLength(0);
-	});
-});
-
-describe("the package entrypoint", () => {
-	test("exports the mount functions a consumer needs", () => {
-		expect(typeof entrypoint.mountProcaptchaPuzzle).toBe("function");
-		expect(typeof entrypoint.loadProcaptchaPuzzle).toBe("function");
-		expect(typeof entrypoint.mountProcaptchaPuzzleWidget).toBe("function");
-	});
-});