@getpinax/widget 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/editor-loader.d.ts

@@ -4,3 +4,6 @@ export declare function setEditorBase(_scriptSrc: string): void;
 export declare function loadEditor(): Promise<EditorModule>;
 /** AI-15: the session recorder, loaded only on sampled Pro and Agency visits. */
 export declare function loadRecorder(): Promise<RecorderModule>;
+/** W-20: axe-core, loaded only when a visitor sends an accessibility report. */
+export type ScannerModule = typeof import('./a11y/scan');
+export declare function loadScanner(): Promise<ScannerModule>;

package/dist/editor-loader.embed.d.ts

@@ -1,5 +1,6 @@
-import type { EditorModule, RecorderModule } from './editor-loader';
+import type { EditorModule, RecorderModule, ScannerModule } from './editor-loader';
 /** Called by embed.ts with the script tag's own src. */
 export declare function setEditorBase(scriptSrc: string): void;
 export declare function loadEditor(): Promise<EditorModule>;
 export declare function loadRecorder(): Promise<RecorderModule>;
+export declare function loadScanner(): Promise<ScannerModule>;

package/dist/fixcheck.d.ts

@@ -9,6 +9,9 @@ import type { FixCheck } from './types';
  * and failed requests (from the existing capture) and, if the same
  * signature shows up, says so once with `POST /fix-check`. Nothing else is
  * ever sent: no "all clear", no page views, no log contents.
+ *
+ * AI-20 / P-17 reuses this watcher for open reports (path `*`): each sampled
+ * page view where the same error shows up sends `POST /sighting` once.
  */
 export type FixCheckOptions = {
     checks: FixCheck[];
@@ -20,6 +23,12 @@ export type FixCheckOptions = {
     path?: () => string;
     random?: () => number;
     now?: () => number;
+    /**
+     * When the first page view's errors count from. Default: the page load,
+     * so errors from before the config arrived are found. A watcher started
+     * again after consent was withdrawn passes now, so nothing is sent twice.
+     */
+    since?: number;
 };
 /** The signature of a single entry, as if it were the report's only one. */
 export declare function consoleSignature(entry: ConsoleEntry): string | null;
@@ -29,3 +38,5 @@ export declare function watchFixChecks(options: FixCheckOptions): {
     navigated: () => void;
     stop: () => void;
 };
+/** `/book` and `/book/` are the same page (known issues use this too). */
+export declare function samePage(a: string, b: string): boolean;

package/dist/index.d.ts

@@ -3,12 +3,19 @@ import { type ConsoleEntry } from './capture/console';
 import { type NetworkEntry } from './capture/network';
 import { RingBuffer } from './capture/ring';
 import type { Recorder } from './replay/recorder';
-import type { PinaxOptions, PinaxUser, WidgetConfig } from './types';
+import { type ReportConsent } from './report';
+import type { PinaxBasket, PinaxConsent, PinaxOptions, PinaxUser, WidgetConfig } from './types';
 import { WidgetUI } from './ui/widget';
-export type { PinaxOptions, PinaxUser } from './types';
+export type { PinaxBasket, PinaxConsent, PinaxOptions, PinaxUser, } from './types';
+type Watcher = {
+    navigated: () => void;
+    stop: () => void;
+};
 type State = {
     options: PinaxOptions;
     api: string;
+    /** P-15: where settings (and, with consent, the page-view count) go. */
+    cdn: string | null;
     root: ShadowRoot;
     user?: PinaxUser;
     config?: WidgetConfig;
@@ -19,6 +26,23 @@ type State = {
     breadcrumbs: RingBuffer<Breadcrumb>;
     /** AI-15: only on sampled Pro and Agency visits, once loaded. */
     recorder?: Recorder;
+    /** AI-15: the recorder chunk is on its way. */
+    replayStarting: boolean;
+    /** AI-15: drawn once per page view, whenever consent comes. */
+    replaySampled: boolean;
+    /** Visitor consent so far (`consent()`); used only where the site waits. */
+    consent: ReportConsent;
+    /** The button is up: enabled site, allowed domain (W-18, S-15). */
+    running: boolean;
+    /** AI-17 fix checks and AI-20 sightings, while they run. */
+    watchers: {
+        fixChecks?: Watcher;
+        sightings?: Watcher;
+    };
+    /** When consent was last withdrawn: watchers started again count from here. */
+    watchersSince?: number;
+    /** B-16: this page load was counted after consent. */
+    counted: boolean;
     /** C-10: stops console or network capture when the site has it off. */
     stopCapture: {
         console?: () => void;
@@ -38,8 +62,23 @@ type State = {
 export declare function init(options: PinaxOptions): void;
 /** Opens the feedback panel from the site's own link or button (S-05). */
 export declare function open(): void;
+/**
+ * Visitor consent from the site's cookie banner: `consent(true)` or
+ * `consent(false)` for everything, or `consent({ diagnostics, replay })`
+ * for only the parts given. Can be called before init(), any number of
+ * times; withdrawing stops what it covers straight away. Only matters where
+ * the page waits for consent (the site's setting or `data-consent="wait"`).
+ */
+export declare function consent(choice: PinaxConsent): void;
 /** Attaches the signed-in visitor to future reports (C-09). Can be called before init(). */
 export declare function identify(user: PinaxUser | null): void;
+/**
+ * AI-21: the visitor's basket total, e.g. `setBasket({ value: 42.5, currency:
+ * 'GBP' })`, or `null` once it's empty. Can be called before init(). Pinax
+ * only sends it alongside a sampled sighting of a known error (P-17).
+ */
+export declare function setBasket(next: PinaxBasket | null): void;
+export declare function cleanBasket(b: unknown): PinaxBasket | undefined;
 /** Removes the widget and stops all capture. Mainly for tests and SPA teardown. */
 export declare function destroy(): void;
 /** @internal */

package/dist/known.d.ts

@@ -0,0 +1,27 @@
+import type { ConsoleEntry } from './capture/console';
+import type { NetworkEntry } from './capture/network';
+import type { RingBuffer } from './capture/ring';
+import type { KnownIssue } from './types';
+/** The card lists at most this many. */
+export declare const MAX_KNOWN_SHOWN = 3;
+/**
+ * Known issues: which of the site's public reports this visitor may be
+ * looking at. One matches when one of its `paths` is this page (`/a` and
+ * `/a/` are the same; `*` means nothing special here), or when its error
+ * signature showed up in this page view's console errors or failed requests.
+ * Every page view is watched (no sampling) and nothing is ever sent: the
+ * result is only used to show the card when the panel opens.
+ */
+export declare function watchKnown(options: {
+    known: KnownIssue[];
+    console: RingBuffer<ConsoleEntry>;
+    network: RingBuffer<NetworkEntry>;
+    path?: () => string;
+    now?: () => number;
+}): {
+    matches: () => KnownIssue[];
+    navigated: () => void;
+    stop: () => void;
+};
+/** The issues for this page, in the config's order (newest first), at most 3. */
+export declare function matchKnown(known: KnownIssue[], path: string, seen?: ReadonlySet<string>): KnownIssue[];