@baas-id/react 0.2.2

package/dist/types/react/document/gate.d.ts

@@ -0,0 +1,114 @@
+import type { Quality } from "../capture";
+import type { CropQuality } from "../vision";
+import { type SpecularSignature } from "../vision/authenticity";
+export { type AuthenticityCue, type CardReading, authenticityCue, cardIssue, holdFraction, paperCue, screenCue } from "./cues";
+export { type AuthenticityTelemetry, heuristicTelemetry, mlTelemetry } from "./telemetry";
+export declare const TICK_MS = 160;
+export declare const ML_TICK_MS = 300;
+export declare const LOCK_FRAMES = 4;
+export declare const LOCK_SHUTTER_MS = 450;
+export declare const HOLD_MS = 1600;
+export declare const MIN_CARD_AREA = 0.14;
+export declare const CARD_AR_MIN = 1.25;
+export declare const CARD_AR_MAX = 2.05;
+export declare const TILT_HOLD_MAX = 35;
+export declare const LOW_CONTRAST_GRACE_MS = 3000;
+export declare const MANUAL_SHUTTER_MS = 10000;
+export declare const DAMAGED_RETRY_LIMIT = 1;
+export declare const TERMINAL_DOC_REASONS: readonly string[];
+export declare function docRejection(reason: string, damagedBefore: number): {
+    code: string;
+    terminal: boolean;
+};
+export declare const REJECTION_NOTICE_MS = 4000;
+export type Phase = "loading" | "searching" | "adjusting" | "steady" | "locked" | "uploading" | "review" | "retake" | "error";
+export type Tone = "info" | "ok" | "warn";
+export declare const GUIDE: {
+    loading: {
+        key: "loading";
+        tone: "info";
+    };
+    no_card: {
+        key: "no_card";
+        tone: "info";
+    };
+    too_far: {
+        key: "too_far";
+        tone: "warn";
+    };
+    bad_framing: {
+        key: "bad_framing";
+        tone: "warn";
+    };
+    tilt_less: {
+        key: "tilt_less";
+        tone: "warn";
+    };
+    low_contrast: {
+        key: "low_contrast";
+        tone: "warn";
+    };
+    screen_suspected: {
+        key: "screen_suspected";
+        tone: "info";
+    };
+    paper_suspected: {
+        key: "paper_suspected";
+        tone: "info";
+    };
+    wrong_side_front: {
+        key: "wrong_side_front";
+        tone: "warn";
+    };
+    wrong_side_back: {
+        key: "wrong_side_back";
+        tone: "warn";
+    };
+    blurred: {
+        key: "blurred";
+        tone: "warn";
+    };
+    glare: {
+        key: "glare";
+        tone: "warn";
+    };
+    too_dark: {
+        key: "too_dark";
+        tone: "warn";
+    };
+    too_bright: {
+        key: "too_bright";
+        tone: "warn";
+    };
+    steady: {
+        key: "steady";
+        tone: "ok";
+    };
+    uploading: {
+        key: "uploading";
+        tone: "info";
+    };
+    mrz_reading: {
+        key: "mrz_reading";
+        tone: "info";
+    };
+    mrz_unreadable: {
+        key: "mrz_unreadable";
+        tone: "warn";
+    };
+    mrz_verified: {
+        key: "mrz_verified";
+        tone: "ok";
+    };
+};
+export type GuideId = keyof typeof GUIDE;
+export type Guidance = (typeof GUIDE)[GuideId];
+export interface Chip {
+    label: "sharpness" | "glare" | "light" | "gloss";
+    state: "idle" | "pass" | "fail";
+}
+export declare const IDLE_CHIPS: Chip[];
+export declare const heuristicOk: (q: Quality) => boolean;
+export declare const heuristicChips: (q: Quality) => Chip[];
+export declare const glossChip: (s?: SpecularSignature | null) => Chip;
+export declare const cropChips: (q: CropQuality, specular?: SpecularSignature | null) => Chip[];

package/dist/types/react/document/latch.d.ts

@@ -0,0 +1,25 @@
+import { AnchoredQuad } from "./flow";
+import { type Box, type Quad } from "./overlay";
+export declare const EDGE_WEIGHT = 0.85;
+export declare const EDGE_HOLD_MS = 700;
+export declare const EDGE_HOLD_IOU = 0.6;
+export type OutlineKind = "edges" | "box";
+export type Locks = [boolean, boolean, boolean, boolean];
+export interface CornerReading {
+    box: Box;
+    corners?: Quad | null;
+    locks?: Locks;
+}
+export declare function iou(a: Box, b: Box): number;
+export declare class CornerLatch {
+    readonly anchored: AnchoredQuad;
+    private kind;
+    private lastEdges;
+    private lockState;
+    constructor(anchored: AnchoredQuad);
+    read(r: CornerReading, t: number): void;
+    get mode(): OutlineKind | null;
+    get locks(): Locks;
+    hint(t: number): Quad | null;
+    reset(): void;
+}

package/dist/types/react/document/mrz.d.ts

@@ -0,0 +1,29 @@
+import type { MrzProbe } from "../capture";
+export declare const MRZ_PROBE_MS = 1100;
+export declare const MRZ_GRACE_MS = 5200;
+export declare const MRZ_READINGS_MAX = 7;
+export type MrzStage = "idle" | "reading" | "unreadable" | "verified" | "absent";
+export type MrzDecision = {
+    kind: "hold";
+    guide: "mrz_reading" | "mrz_unreadable";
+} | {
+    kind: "release";
+    becameAbsent: boolean;
+};
+export declare class MrzGate {
+    inFlight: boolean;
+    lastAt: number;
+    verified: boolean;
+    seen: boolean;
+    unavailable: boolean;
+    readonly readings: string[];
+    readonly enabled: boolean;
+    constructor(enabled: boolean);
+    get initialStage(): MrzStage;
+    private get active();
+    claimProbe(now: number): boolean;
+    settle(res: MrzProbe | null): MrzStage | null;
+    abandon(): void;
+    decide(now: number, goodSince: number): MrzDecision;
+    reset(): void;
+}

package/dist/types/react/document/overlay.d.ts

@@ -0,0 +1,52 @@
+export type Pt = {
+    x: number;
+    y: number;
+};
+export type Quad = [Pt, Pt, Pt, Pt];
+export type Box = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export interface ViewMap {
+    srcW: number;
+    srcH: number;
+    viewW: number;
+    viewH: number;
+    fit?: "cover" | "contain";
+    mirror?: boolean;
+}
+export declare const ID1_ASPECT: number;
+export declare const ID1_RADIUS: number;
+export declare const TARGET_WIDTH = 0.84;
+export declare const OUTLINE_PAD = 0.02;
+export declare const SMOOTHING = 0.5;
+export declare const JUMP = 0.12;
+export declare const LOST_TICKS = 2;
+export declare function fitTransform(m: ViewMap): {
+    scale: number;
+    dx: number;
+    dy: number;
+};
+export declare function toView(p: Pt, m: ViewMap): Pt;
+export declare function toSource(p: Pt, m: ViewMap): Pt;
+export declare const boxQuad: (b: Box) => Quad;
+export declare function mapQuad(q: Quad, m: ViewMap): Quad | null;
+export declare function sourceBox(q: Quad, m: ViewMap): Box;
+export declare const cssToBacking: (p: Pt, dpr: number) => Pt;
+export declare function targetQuad(viewW: number, viewH: number, width?: number): Quad;
+export declare const centroid: (q: Quad) => Pt;
+export declare function expandQuad(q: Quad, pad?: number): Quad;
+export declare const lerpQuad: (a: Quad, b: Quad, t: number) => Quad;
+export declare const quadShift: (a: Quad, b: Quad) => number;
+export declare class QuadTracker {
+    private quad;
+    private pending;
+    private misses;
+    seen(q: Quad): Quad;
+    missed(): Quad | null;
+    reset(): void;
+}
+export declare function roundedQuadPath(q: Quad, r: number): string;
+export declare const quadWidth: (q: Quad) => number;

package/dist/types/react/document/quad.d.ts

@@ -0,0 +1,5 @@
+import { type CornerOptions, type CornerResult, type Gray, type Planes } from "../vision/corners";
+import type { Box, Quad } from "./overlay";
+export { grayOf, planesOf, findCorners, type CornerResult, type Gray, type Planes } from "../vision/corners";
+export declare function refineQuad(g: Gray | Planes, box: Box, opts?: CornerOptions): Quad | null;
+export declare const cornersOf: (g: Gray | Planes, box: Box, opts?: CornerOptions) => CornerResult;

package/dist/types/react/document/resolution.d.ts

@@ -0,0 +1,42 @@
+export interface Box {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare const WORK_LONG_SIDE = 1280;
+export declare const UPLOAD_LONG_MAX = 1600;
+export declare const UPLOAD_MARGIN = 0.03;
+export declare const UPLOAD_JPEG_QUALITY = 0.9;
+export declare const EXTRA_JPEG_QUALITY = 0.85;
+export declare const EXTRA_JPEG_QUALITY_LOW = 0.75;
+export declare const UPLOAD_BUDGET_BYTES = 1500000;
+export declare const IOD_PER_CARD_PX = 0.062;
+export declare const SERVER_IOD_MIN = 39;
+export declare const CARD_PX_GOAL = 1000;
+export declare const CARD_PX_FLOOR = 680;
+export declare const FILL_ASK = 0.8;
+export declare const FILL_MAX = 0.92;
+export declare const ID1_ASPECT: number;
+export declare function fitLong(w: number, h: number, long: number): {
+    w: number;
+    h: number;
+    k: number;
+};
+export declare const workSize: (w: number, h: number) => {
+    w: number;
+    h: number;
+    k: number;
+};
+export declare function scaleBox(b: Box, kx: number, ky?: number): Box;
+export declare function uploadRect(b: Box, W: number, H: number, margin?: number): Box;
+export declare function uploadSize(r: Box, maxLong?: number): {
+    w: number;
+    h: number;
+};
+export declare const cardLongPx: (b: Box) => number;
+export declare function cardPxInUpload(b: Box, W: number, H: number): number;
+export declare const expectedIod: (px: number) => number;
+export declare const maxCardLongPx: (W: number, H: number) => number;
+export declare function requiredCardPx(W: number, H: number): number;
+export declare function extrasThatFit(primaryBytes: number, extraBytes: readonly number[], budget?: number): number;

package/dist/types/react/document/review.d.ts

@@ -0,0 +1,50 @@
+import type { Strings } from "../i18n";
+export interface ExtractionLike {
+    fields?: Record<string, {
+        value?: unknown;
+        sources?: string[];
+        agreed?: boolean;
+    } | undefined>;
+    sources?: Array<{
+        kind?: string;
+        valid?: boolean | null;
+        raw?: unknown;
+    }>;
+    portrait?: {
+        present?: boolean;
+        box?: number[] | null;
+    } | null;
+}
+export interface ReviewRegion {
+    key: string;
+    label: string;
+    l: number;
+    t: number;
+    w: number;
+    h: number;
+}
+export interface ReviewField {
+    key: string;
+    label: string;
+    value: string;
+    confirmed: boolean;
+}
+export interface Review {
+    regions: ReviewRegion[];
+    fields: ReviewField[];
+}
+export declare function maskNumber(v: string): string;
+export declare function reviewOf(x: ExtractionLike | null | undefined, imgW: number, imgH: number, t: Strings): Review;
+export declare const hasReview: (r: Review) => boolean;
+export interface CardInset {
+    x: number;
+    y: number;
+}
+export declare function cardInset(margin: number, aspect?: number): CardInset;
+export interface ReviewView {
+    image: string;
+    aspect: number;
+    review: Review;
+    confirm: boolean;
+    outline: CardInset | null;
+}

package/dist/types/react/document/sideCheck.d.ts

@@ -0,0 +1,32 @@
+import type { Side } from "../flows/state";
+import type { Strings } from "../i18n";
+export interface SideCopy {
+    reason: string;
+    title?: string;
+    description?: string;
+    mismatches: string[];
+    action?: string;
+}
+export type SideOutcome = {
+    kind: "ok";
+} | ({
+    kind: "retake";
+    target: Side;
+} & SideCopy) | ({
+    kind: "hint";
+    suggest: "continue" | "retake";
+} & SideCopy);
+export declare function sideOutcomeOf(side: Side, res: unknown): SideOutcome;
+export declare function fallbackCopy(o: Exclude<SideOutcome, {
+    kind: "ok";
+}>, side: Side, t: Strings): {
+    title: string;
+    description: string;
+};
+export declare function retakeText(o: Exclude<SideOutcome, {
+    kind: "ok";
+}>, side: Side, t: Strings): {
+    title: string;
+    description: string;
+    fields: string | null;
+};

package/dist/types/react/document/telemetry.d.ts

@@ -0,0 +1,14 @@
+import type { Strings } from "../i18n";
+import type { Quality } from "../capture";
+import type { CropQuality } from "../vision";
+import { type SpecularSignature } from "../vision/authenticity";
+import type { AuthenticityCue } from "./cues";
+export interface AuthenticityTelemetry {
+    grid: number;
+    specular: SpecularSignature;
+    corner: number | null;
+    cue: AuthenticityCue | null;
+    texture?: number;
+}
+export declare function mlTelemetry(t: Strings, cardConf: number, isFront: boolean, sideConf: number, q: Pick<CropQuality, "blurScore" | "brightness">, moire: number, auth?: AuthenticityTelemetry): string;
+export declare function heuristicTelemetry(t: Strings, side: "front" | "back", q: Quality, ok: boolean): string;

package/dist/types/react/document/track.d.ts

@@ -0,0 +1,36 @@
+import type { Pt, Quad } from "./overlay";
+export declare const PREDICT_MAX_MS = 220;
+export declare const LOST_MS = 700;
+export declare const TRACK_JUMP = 0.16;
+export declare const ALPHA_REST = 0.45;
+export declare const ALPHA_MOVING = 0.92;
+export declare const betaFor: (alpha: number) => number;
+export declare const SPEED_FULL = 0.5;
+export declare const SPEED_DEADBAND = 0.02;
+export declare const SPEED_MAX = 4;
+export declare const MIN_VELOCITY_DT = 12;
+export declare class PointsMotion {
+    private readonly jump;
+    private p;
+    private v;
+    private t;
+    private pending;
+    private lastSeen;
+    constructor(jump?: number);
+    seen(pts: readonly Pt[], t: number): void;
+    pointsAt(now: number): Pt[] | null;
+    tracking(now: number): boolean;
+    reset(): void;
+    private adopt;
+}
+export declare class QuadMotion extends PointsMotion {
+    seenQuad(q: Quad, t: number): void;
+    at(now: number): Quad | null;
+}
+export interface QuadSource {
+    at(now: number): Quad | null;
+    info?(): {
+        kind: "edges" | "box" | null;
+        locks: readonly [boolean, boolean, boolean, boolean];
+    };
+}

package/dist/types/react/document/useDocumentCapture.d.ts

@@ -0,0 +1,78 @@
+import { type EngineProgress } from "../vision";
+import type { DocumentCaptureProps } from "../DocumentCapture";
+import { type Chip, type Guidance, type Phase } from "./gate";
+import { type MrzStage } from "./mrz";
+import { type Advisory } from "./advisory";
+import { type Box, type Quad } from "./overlay";
+import { type QuadSource } from "./track";
+import { type ReviewView } from "./review";
+export interface SnapshotFrom {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+export interface Snapshot {
+    url: string;
+    aspect: number;
+    from: SnapshotFrom | null;
+}
+export declare const LOCK_MS = 520;
+export declare const REVIEW_MS = 2600;
+export declare function cutUpload(full: HTMLCanvasElement, b: Box): HTMLCanvasElement;
+export interface UploadCandidate {
+    canvas: HTMLCanvasElement;
+    quad: Quad | null;
+}
+export declare function cutCard(full: HTMLCanvasElement, b: Box, quad?: Quad | null): UploadCandidate;
+export declare function useDocumentCapture(props: DocumentCaptureProps): {
+    t: import("../i18n").Strings;
+    videoRef: import("react").RefObject<HTMLVideoElement>;
+    canvasRef: import("react").RefObject<HTMLCanvasElement>;
+    source: "camera" | "demo";
+    phase: Phase;
+    guide: Guidance;
+    chips: Chip[];
+    holdPct: number;
+    tracking: boolean;
+    track: QuadSource;
+    hint: Advisory | null;
+    error: string | null;
+    tele: string;
+    retake: ({
+        kind: "retake";
+        target: import("../flows/state").Side;
+    } & import("./sideCheck").SideCopy) | ({
+        kind: "hint";
+        suggest: "continue" | "retake";
+    } & import("./sideCheck").SideCopy) | null;
+    finalCopy: {
+        title?: string;
+        description?: string;
+    } | null;
+    retakeAgain: () => void | undefined;
+    retakeProceed: () => void | undefined;
+    confirmUse: () => void | undefined;
+    confirmRetake: () => void | undefined;
+    loadProgress: EngineProgress | null;
+    engineReady: boolean;
+    mrz: {
+        found: boolean;
+        raw_text?: string | null;
+        type?: string | null;
+        valid?: boolean;
+        fields_valid?: boolean;
+        score?: number | null;
+        checks?: Record<string, boolean>;
+        failed?: string[];
+        fields?: Record<string, string | null>;
+    } | null;
+    mrzStage: MrzStage;
+    retry: () => void;
+    retriesLeft: number | null;
+    final: boolean;
+    manualReady: boolean;
+    shutter: () => void | undefined;
+    review: ReviewView | null;
+    snapshot: Snapshot | null;
+};

package/dist/types/react/face/FaceGuide.d.ts

@@ -0,0 +1,22 @@
+import type { GuideKey, Strings } from "../i18n";
+import { type Ellipse } from "./faceView";
+import type { PointsMotion } from "../document/track";
+import { type ScanState } from "./scanState";
+export type FaceGuideState = "neutral" | "aligned" | "capturing" | "done" | "warn";
+export type FaceCue = "turn_left" | "turn_right" | "move_closer" | null;
+export declare function FaceGuide({ src, oval, motion, state, scan, fills, progress, cue, guide, errorKey, t, }: {
+    src: {
+        w: number;
+        h: number;
+    };
+    oval: Ellipse;
+    motion: PointsMotion;
+    state: FaceGuideState;
+    scan: ScanState;
+    fills: number[];
+    progress: number;
+    cue: FaceCue;
+    guide: GuideKey;
+    errorKey?: string | null;
+    t: Strings;
+}): import("react").JSX.Element;

package/dist/types/react/face/FaceParts.d.ts

@@ -0,0 +1,15 @@
+import type { Strings } from "../i18n";
+import type { ChallengeKind } from "../liveness";
+export declare function ChallengeList({ script, step, t }: {
+    script: ChallengeKind[];
+    step: number;
+    t: Strings;
+}): import("react").JSX.Element;
+export declare function faceGuideStateOf(s: {
+    error: string | null;
+    phase: string;
+    step: number;
+    total: number;
+    found: boolean;
+    guide: string;
+}): "neutral" | "aligned" | "capturing" | "done" | "warn";

package/dist/types/react/face/faceMesh.d.ts

@@ -0,0 +1,68 @@
+import type { Pt } from "../document/overlay";
+import type { FaceMark } from "./faceView";
+export declare const MESH_DEPTH = 0.78;
+export declare const MESH_EYE: {
+    x: number;
+    y: number;
+    r: number;
+};
+export declare const MESH_NOSE: {
+    x: number;
+    y: number;
+};
+export declare const MESH_MOUTH: {
+    y: number;
+    rx: number;
+    ry: number;
+};
+export declare const YAW_LIMIT = 1.05;
+export declare function halfWidth(y: number): number;
+export declare function surfaceZ(x: number, y: number): number;
+export interface FaceMesh {
+    dots: Float32Array;
+    count: number;
+    lines: Float32Array[];
+}
+export declare const DOT_STRIDE = 5;
+export declare function featureLines(): Float32Array[];
+export declare function buildFaceMesh(spacing?: number): FaceMesh;
+export interface FacePose {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    roll: number;
+    yaw: number;
+}
+export declare function poseOf(mark: FaceMark): FacePose;
+export interface Projected extends Pt {
+    facing: number;
+}
+export declare function projectPoint(p: FacePose, x: number, y: number, z: number, out: Projected): Projected;
+export declare function poseCentre(p: FacePose): Pt;
+export declare function smoothstep(e0: number, e1: number, v: number): number;
+export declare function revealAlpha(d: number, t: number): number;
+export declare function sweepGlow(y: number, s: number, width?: number): number;
+export declare function sweepY(t: number): number;
+export declare function latitude(y: number, n?: number): Float32Array;
+export declare class OneEuro {
+    private readonly minCutoff;
+    private readonly beta;
+    private readonly dCutoff;
+    private x;
+    private dx;
+    private t;
+    constructor(minCutoff?: number, beta?: number, dCutoff?: number);
+    private static alpha;
+    filter(v: number, t: number): number;
+    reset(): void;
+}
+export declare class PointsEuro {
+    private readonly minCutoff;
+    private readonly beta;
+    private fx;
+    private fy;
+    constructor(minCutoff?: number, beta?: number);
+    filter(pts: readonly Pt[], t: number): Pt[];
+    reset(): void;
+}

package/dist/types/react/face/faceRegion.d.ts

@@ -0,0 +1,16 @@
+import type { FaceSignals } from "../liveness";
+import type { ProbeRegion } from "../capture";
+export declare function faceRegion(s: Pick<FaceSignals, "faceFrac" | "cx" | "cy" | "geom"> | null, W: number, H: number): ProbeRegion | number;
+export declare function faceBox(s: Pick<FaceSignals, "faceFrac" | "cx" | "cy" | "geom">, W: number, H: number, pad?: number): ProbeRegion;
+export declare const OVAL_WIDTH = 0.76;
+export declare const OVAL_ASPECT = 1.3;
+export declare const OVAL_CY = 0.45;
+export declare function ovalFor(v: {
+    videoWidth: number;
+    videoHeight: number;
+}): {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+};

package/dist/types/react/face/faceView.d.ts

@@ -0,0 +1,21 @@
+import { type Pt, type ViewMap } from "../document/overlay";
+import type { FaceGeometry } from "../liveness";
+export interface Ellipse {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+}
+export declare const faceViewMap: (srcW: number, srcH: number, viewW: number, viewH: number) => ViewMap;
+export declare function ovalToView(o: Ellipse, m: ViewMap): Ellipse;
+export declare function trackPoints(g: FaceGeometry): Pt[];
+export interface FaceMark {
+    face: Ellipse;
+    eyes: [Pt, Pt];
+    nose: Pt;
+    mouth?: Pt;
+    ears?: [Pt, Pt];
+}
+export declare function faceMarkToView(pts: readonly Pt[], srcW: number, srcH: number, m: ViewMap): FaceMark | null;
+export declare const ovalFill: (faceW: number, oval: Ellipse) => number;
+export declare function ellipsePath(e: Ellipse): string;

package/dist/types/react/face/meshBench.d.ts

@@ -0,0 +1,7 @@
+export interface MeshBench {
+    msMean: number;
+    msP90: number;
+    fps: number;
+    points: number;
+}
+export declare function meshBenchmark(frames?: number, w?: number, h?: number, dpr?: number): MeshBench;

package/dist/types/react/face/meshCanvas.d.ts

@@ -0,0 +1,20 @@
+import { type FaceMesh, type FacePose } from "./faceMesh";
+export interface MeshFrame {
+    alpha: number;
+    tone: string;
+    reveal: number;
+    sweep: number | null;
+    sweepFade: number;
+    contours: boolean;
+}
+export declare class MeshPainter {
+    private readonly mesh;
+    private readonly px;
+    private readonly py;
+    private readonly pr;
+    private readonly pb;
+    private readonly tmp;
+    constructor(mesh: FaceMesh);
+    draw(ctx: CanvasRenderingContext2D, pose: FacePose, f: MeshFrame): void;
+    private trace;
+}