@oxy.so/bloom 4.0.0 → 4.1.0

package/lib/module/proof-of-delivery/SignaturePad.js

@@ -0,0 +1,288 @@
+"use strict";
+
+import React, { memo, useCallback, useMemo, useRef, useState } from 'react';
+import { PanResponder, View } from 'react-native';
+import Svg, { Line, Path } from 'react-native-svg';
+import { Button } from '../button';
+import { Field } from "../field/index.js";
+import { useControllableState } from "../hooks/use-controllable-state.js";
+import { RiDeleteBinLine } from "../icons/remix/RiDeleteBinLine.js";
+import { SurfaceLevelProvider, useSurfaceFill } from "../styles/surface-levels.js";
+import { DISABLED_OPACITY } from "../styles/tokens.js";
+import { TextFieldInput } from "../text-field/index.js";
+import { useTheme } from "../theme/use-theme.js";
+import { Text } from "../typography/index.js";
+import { PROOF_GEOMETRY, PROOF_LABELS } from "./constants.js";
+import { EMPTY_SIGNATURE, hasSignatureInk, resolveProofPaint, shouldKeepSignaturePoint, signaturePath } from "./shared.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * A signature, drawn with a finger — and the same signature typed, for everyone
+ * who cannot draw one.
+ *
+ *   pad      a filled surface at the next level up, radius 12, with a baseline
+ *            hairline at 72% of its height: a signature is written ON a line,
+ *            and without one a finger starts wherever it lands
+ *   ink      one `<Path>` per stroke, quadratic through the midpoints of the
+ *            samples (`signaturePath`), round caps and joins, painted in the
+ *            TEXT colour — a signature is writing, not a brand mark
+ *   hint     under the pad, replaced by "Signed" once there is ink
+ *   clear    a `text` `Button`, drawn only once there is something to clear
+ *   typed    a `TextFieldInput` under it all, always present
+ *
+ * ## The typed field is not a fallback, it is the other half of the control
+ *
+ * A pad is a pointer affordance: there is no keyboard gesture for it, a screen
+ * reader has nothing to announce but an empty box, and a motor impairment makes
+ * it unusable. So both paths are drawn AT ONCE rather than behind a mode
+ * switch — a mode a reader has to find is a mode most readers never find — and
+ * `isSignatureGiven` treats ink and a typed name as the same answer.
+ *
+ * `typed={false}` removes it. That is a deliberate escape hatch for an app that
+ * collects the name in a field of its own on the same screen, and it is the
+ * only way to ship this control with no accessible path at all.
+ *
+ * ## The pointer
+ *
+ * One `PanResponder`, which react-native-web routes from real mouse, touch and
+ * pen events through its own responder system — so the same file draws on both
+ * platforms and there is no `.web` fork to keep in step. Points arrive in the
+ * pad's own coordinates (`locationX` / `locationY`, which RNW measures against
+ * the responder node), so a scrolled or transformed page needs no correction.
+ *
+ * Samples closer together than 2px are dropped (`shouldKeepSignaturePoint`):
+ * a resting finger reports the same coordinate many times a second, and every
+ * repeat is a zero-length curve the smoothing then has to average out.
+ *
+ * **A jest test cannot see any of this.** The path geometry is pure and pinned
+ * in `src/__tests__/ProofOfDelivery.test.tsx`; that ink actually lands under a
+ * real pointer is pinned in `scripts/verify-signature-pad.mjs`, with
+ * `page.mouse.down/move/up` and the emitted `<path d>`.
+ */
+
+const asPoint = event => ({
+  x: event.nativeEvent.locationX,
+  y: event.nativeEvent.locationY
+});
+function SignaturePadComponent({
+  value: valueProp,
+  defaultValue,
+  onChange,
+  onStrokeEnd,
+  height = PROOF_GEOMETRY.padHeight,
+  ink,
+  strokeWidth = PROOF_GEOMETRY.strokeWidth,
+  typed = true,
+  disabled = false,
+  labels: labelOverrides,
+  accessibilityLabel,
+  style,
+  testID
+}) {
+  const theme = useTheme();
+  const surface = useSurfaceFill();
+  const paint = useMemo(() => resolveProofPaint(theme, surface), [theme, surface]);
+  const labels = useMemo(() => ({
+    ...PROOF_LABELS,
+    ...labelOverrides
+  }), [labelOverrides]);
+  const [value, setValue] = useControllableState({
+    value: valueProp,
+    defaultValue: defaultValue ?? EMPTY_SIGNATURE,
+    onChange
+  });
+  const [size, setSize] = useState(null);
+  /** The stroke under the finger, kept in state so the ink follows it. */
+  const [live, setLive] = useState([]);
+
+  // The responder is created ONCE — its handlers close over the first render —
+  // so everything they need goes through a ref that every render refreshes.
+  const latest = useRef({
+    value,
+    setValue,
+    onStrokeEnd,
+    disabled
+  });
+  latest.current = {
+    value,
+    setValue,
+    onStrokeEnd,
+    disabled
+  };
+  const liveRef = useRef([]);
+  const responder = useMemo(() => PanResponder.create({
+    onStartShouldSetPanResponder: () => !latest.current.disabled,
+    onMoveShouldSetPanResponder: () => !latest.current.disabled,
+    // The pad KEEPS the gesture once it has it: a signature crosses a
+    // scroller and an ancestor that could steal it mid-word would break the
+    // stroke in half and leave the second half unrecorded.
+    onPanResponderTerminationRequest: () => false,
+    onPanResponderGrant: event => {
+      if (latest.current.disabled) return;
+      const point = asPoint(event);
+      liveRef.current = [point];
+      setLive(liveRef.current);
+    },
+    onPanResponderMove: event => {
+      if (latest.current.disabled) return;
+      const point = asPoint(event);
+      const last = liveRef.current[liveRef.current.length - 1];
+      if (!shouldKeepSignaturePoint(last, point)) return;
+      liveRef.current = [...liveRef.current, point];
+      setLive(liveRef.current);
+    },
+    onPanResponderRelease: () => {
+      const stroke = liveRef.current;
+      liveRef.current = [];
+      setLive([]);
+      if (stroke.length === 0) return;
+      const current = latest.current.value;
+      latest.current.setValue({
+        ...current,
+        strokes: [...current.strokes, stroke]
+      });
+      latest.current.onStrokeEnd?.(stroke);
+    },
+    onPanResponderTerminate: () => {
+      liveRef.current = [];
+      setLive([]);
+    }
+  }), []);
+  const onLayout = useCallback(event => {
+    const {
+      width,
+      height: measured
+    } = event.nativeEvent.layout;
+    setSize(prev => prev && prev.width === width && prev.height === measured ? prev : {
+      width,
+      height: measured
+    });
+  }, []);
+  const clear = useCallback(() => {
+    liveRef.current = [];
+    setLive([]);
+    setValue({
+      ...value,
+      strokes: []
+    });
+  }, [setValue, value]);
+  const strokes = value.strokes;
+  const hasInk = hasSignatureInk(value) || live.length > 0;
+  const id = part => testID ? `${testID}-${part}` : undefined;
+  const inkColor = ink ?? paint.padText.text;
+  const padName = accessibilityLabel ?? labels.signaturePad;
+  return /*#__PURE__*/_jsxs(View, {
+    style: [{
+      gap: PROOF_GEOMETRY.blockGap,
+      opacity: disabled ? DISABLED_OPACITY : 1
+    }, style],
+    testID: testID,
+    children: [/*#__PURE__*/_jsx(SurfaceLevelProvider, {
+      level: 1,
+      fill: paint.pad,
+      children: /*#__PURE__*/_jsx(View, {
+        onLayout: onLayout,
+        ...responder.panHandlers,
+        // The drawn signature IS an image: it is not operable by keyboard and
+        // holds no state ARIA can read, so it announces what it is and the
+        // typed field below carries the input semantics.
+        role: "img",
+        accessibilityLabel: hasInk ? `${padName}, ${labels.signed}` : padName,
+        style: {
+          height,
+          width: '100%',
+          overflow: 'hidden',
+          borderRadius: PROOF_GEOMETRY.padRadius,
+          // A hairline as well as the fill: one surface step up from the page
+          // is a small step by design, and without an EDGE the pad reads as a
+          // gap in the form rather than as somewhere to write. Every other
+          // control around it draws one.
+          borderWidth: 1,
+          borderColor: paint.hairline,
+          backgroundColor: paint.pad
+        },
+        testID: id('pad'),
+        children: size ? /*#__PURE__*/_jsxs(Svg, {
+          width: size.width,
+          height: size.height,
+          pointerEvents: "none",
+          children: [/*#__PURE__*/_jsx(Line, {
+            x1: PROOF_GEOMETRY.baselineInset,
+            x2: Math.max(PROOF_GEOMETRY.baselineInset, size.width - PROOF_GEOMETRY.baselineInset),
+            y1: size.height * PROOF_GEOMETRY.baseline,
+            y2: size.height * PROOF_GEOMETRY.baseline,
+            stroke: paint.hairline,
+            strokeWidth: 1,
+            testID: id('baseline')
+          }), strokes.map((stroke, index) => /*#__PURE__*/_jsx(Path, {
+            d: signaturePath(stroke),
+            stroke: inkColor,
+            strokeWidth: strokeWidth,
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            fill: "none",
+            testID: id(`stroke-${index}`)
+          }, index)), live.length > 0 ? /*#__PURE__*/_jsx(Path, {
+            d: signaturePath(live),
+            stroke: inkColor,
+            strokeWidth: strokeWidth,
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            fill: "none",
+            testID: id('stroke-live')
+          }) : null]
+        }) : null
+      })
+    }), /*#__PURE__*/_jsxs(View, {
+      style: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        gap: 8
+      },
+      children: [/*#__PURE__*/_jsx(Text, {
+        variant: "body-2-regular",
+        numberOfLines: 1,
+        style: {
+          flexShrink: 1,
+          color: paint.textSecondary
+        },
+        testID: id('hint'),
+        children: hasInk ? labels.signed : labels.signatureHint
+      }), hasInk ? /*#__PURE__*/_jsx(Button, {
+        variant: "text",
+        size: "small",
+        leadingIcon: RiDeleteBinLine,
+        onPress: clear,
+        disabled: disabled,
+        accessibilityLabel: labels.clear,
+        testID: id('clear'),
+        children: labels.clear
+      }) : null]
+    }), typed ?
+    /*#__PURE__*/
+    // Its OWN `Field`, nested inside whatever field the pad is in. Without
+    // it the typed input inherits the outer field's label — `TextFieldInput`
+    // resolves its name as `field.labelText ?? label` and offers the caller
+    // no override — so the words "Or type your name" would be drawn nowhere
+    // and announced as "Signature", the same as the pad beside it.
+    _jsx(Field, {
+      label: labels.typeName,
+      disabled: disabled,
+      children: /*#__PURE__*/_jsx(TextFieldInput, {
+        label: labels.typeName,
+        placeholder: labels.typeNamePlaceholder,
+        value: value.typedName ?? '',
+        onChangeText: text => setValue({
+          ...value,
+          typedName: text
+        }),
+        disabled: disabled,
+        autoCapitalize: "words",
+        testID: id('typed')
+      })
+    }) : null]
+  });
+}
+export const SignaturePad = /*#__PURE__*/memo(SignaturePadComponent);
+SignaturePad.displayName = 'SignaturePad';
+//# sourceMappingURL=SignaturePad.js.map

package/lib/module/proof-of-delivery/SignaturePad.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","memo","useCallback","useMemo","useRef","useState","PanResponder","View","Svg","Line","Path","Button","Field","useControllableState","RiDeleteBinLine","SurfaceLevelProvider","useSurfaceFill","DISABLED_OPACITY","TextFieldInput","useTheme","Text","PROOF_GEOMETRY","PROOF_LABELS","EMPTY_SIGNATURE","hasSignatureInk","resolveProofPaint","shouldKeepSignaturePoint","signaturePath","jsx","_jsx","jsxs","_jsxs","asPoint","event","x","nativeEvent","locationX","y","locationY","SignaturePadComponent","value","valueProp","defaultValue","onChange","onStrokeEnd","height","padHeight","ink","strokeWidth","typed","disabled","labels","labelOverrides","accessibilityLabel","style","testID","theme","surface","paint","setValue","size","setSize","live","setLive","latest","current","liveRef","responder","create","onStartShouldSetPanResponder","onMoveShouldSetPanResponder","onPanResponderTerminationRequest","onPanResponderGrant","point","onPanResponderMove","last","length","onPanResponderRelease","stroke","strokes","onPanResponderTerminate","onLayout","width","measured","layout","prev","clear","hasInk","id","part","undefined","inkColor","padText","text","padName","signaturePad","gap","blockGap","opacity","children","level","fill","pad","panHandlers","role","signed","overflow","borderRadius","padRadius","borderWidth","borderColor","hairline","backgroundColor","pointerEvents","x1","baselineInset","x2","Math","max","y1","baseline","y2","map","index","d","strokeLinecap","strokeLinejoin","flexDirection","alignItems","justifyContent","variant","numberOfLines","flexShrink","color","textSecondary","signatureHint","leadingIcon","onPress","label","typeName","placeholder","typeNamePlaceholder","typedName","onChangeText","autoCapitalize","SignaturePad","displayName"],"sourceRoot":"../../../src","sources":["proof-of-delivery/SignaturePad.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/proof-of-delivery/constants.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { RADIUS } from "../design-tokens/scales.js";
+/** Every default word the family draws. */
+export const PROOF_LABELS = {
+  signature: 'Signature',
+  signaturePad: 'Signature',
+  signatureHint: 'Sign with your finger',
+  signed: 'Signed',
+  clear: 'Clear the signature',
+  typeName: 'Or type your name',
+  typeNamePlaceholder: 'Full name',
+  photo: 'Photo',
+  photoHint: 'Where you left it, or the parcel with the recipient.',
+  code: 'Delivery code',
+  codeHint: 'Ask the recipient to read out the code in their app.',
+  recipient: 'Who received it',
+  recipientPlaceholder: 'Name',
+  note: 'Note',
+  notePlaceholder: 'Anything worth recording',
+  submit: 'Confirm the delivery',
+  required: 'Required',
+  missing: 'This is needed before you can confirm.',
+  missingSummary: count => count === 1 ? 'One thing is still missing' : `${count} things are still missing`
+};
+
+/**
+ * The order the door is worked through, and it is not arbitrary.
+ *
+ * Recipient first, because it is the one question the courier asks out loud and
+ * the answer to it decides the rest. Then the two proofs the RECIPIENT takes
+ * part in — the signature they give and the code they read out — then the photo,
+ * which is taken after they have gone, and the note last, because it is written
+ * about everything above it.
+ */
+export const PROOF_ORDER = ['recipient', 'signature', 'code', 'photo', 'note'];
+
+/**
+ * The pad's geometry.
+ *
+ * `baseline` is where the rule sits as a fraction of the height: a signature is
+ * written ON a line, and without one a finger starts wherever it lands and the
+ * capture reads as a doodle. 0.72 leaves a descender's worth of room under it.
+ */
+export const PROOF_GEOMETRY = {
+  padHeight: 180,
+  padRadius: RADIUS['radius-12'],
+  baseline: 0.72,
+  /** How far in from each side the baseline stops. */
+  baselineInset: 16,
+  strokeWidth: 2.5,
+  /** Between the blocks of the form. */
+  gap: 20,
+  /** Between a block's own parts. */
+  blockGap: 8,
+  /**
+   * How far a finger must travel before a press becomes a stroke. Below it a
+   * single tap still records a DOT, which is what a full stop in a signature
+   * is — the threshold decides smoothing, never whether ink was laid down.
+   */
+  smoothing: 2
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/proof-of-delivery/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RADIUS","PROOF_LABELS","signature","signaturePad","signatureHint","signed","clear","typeName","typeNamePlaceholder","photo","photoHint","code","codeHint","recipient","recipientPlaceholder","note","notePlaceholder","submit","required","missing","missingSummary","count","PROOF_ORDER","PROOF_GEOMETRY","padHeight","padRadius","baseline","baselineInset","strokeWidth","gap","blockGap","smoothing"],"sourceRoot":"../../../src","sources":["proof-of-delivery/constants.ts"],"mappings":";;AAAA,SAASA,MAAM,QAAQ,4BAAyB;AAGhD;AACA,OAAO,MAAMC,YAA6C,GAAG;EAC3DC,SAAS,EAAE,WAAW;EACtBC,YAAY,EAAE,WAAW;EACzBC,aAAa,EAAE,uBAAuB;EACtCC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,qBAAqB;EAC5BC,QAAQ,EAAE,mBAAmB;EAC7BC,mBAAmB,EAAE,WAAW;EAChCC,KAAK,EAAE,OAAO;EACdC,SAAS,EAAE,sDAAsD;EACjEC,IAAI,EAAE,eAAe;EACrBC,QAAQ,EAAE,sDAAsD;EAChEC,SAAS,EAAE,iBAAiB;EAC5BC,oBAAoB,EAAE,MAAM;EAC5BC,IAAI,EAAE,MAAM;EACZC,eAAe,EAAE,0BAA0B;EAC3CC,MAAM,EAAE,sBAAsB;EAC9BC,QAAQ,EAAE,UAAU;EACpBC,OAAO,EAAE,wCAAwC;EACjDC,cAAc,EAAGC,KAAa,IAC5BA,KAAK,KAAK,CAAC,GAAG,4BAA4B,GAAG,GAAGA,KAAK;AACzD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,WAAiC,GAAG,CAC/C,WAAW,EACX,WAAW,EACX,MAAM,EACN,OAAO,EACP,MAAM,CACP;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,cAAc,GAAG;EAC5BC,SAAS,EAAE,GAAG;EACdC,SAAS,EAAEzB,MAAM,CAAC,WAAW,CAAC;EAC9B0B,QAAQ,EAAE,IAAI;EACd;EACAC,aAAa,EAAE,EAAE;EACjBC,WAAW,EAAE,GAAG;EAChB;EACAC,GAAG,EAAE,EAAE;EACP;EACAC,QAAQ,EAAE,CAAC;EACX;AACF;AACA;AACA;AACA;EACEC,SAAS,EAAE;AACb,CAAU","ignoreList":[]}

package/lib/module/proof-of-delivery/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export { ProofOfDelivery } from "./ProofOfDelivery.js";
+export { SignaturePad } from "./SignaturePad.js";
+export { PROOF_GEOMETRY, PROOF_LABELS, PROOF_ORDER } from "./constants.js";
+export { EMPTY_PROOF, EMPTY_SIGNATURE, completeProofValue, hasSignatureInk, isProofGiven, isSignatureGiven, missingProofs, orderProofs, resolveProofPaint, shouldKeepSignaturePoint, signaturePath } from "./shared.js";
+//# sourceMappingURL=index.js.map

package/lib/module/proof-of-delivery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ProofOfDelivery","SignaturePad","PROOF_GEOMETRY","PROOF_LABELS","PROOF_ORDER","EMPTY_PROOF","EMPTY_SIGNATURE","completeProofValue","hasSignatureInk","isProofGiven","isSignatureGiven","missingProofs","orderProofs","resolveProofPaint","shouldKeepSignaturePoint","signaturePath"],"sourceRoot":"../../../src","sources":["proof-of-delivery/index.ts"],"mappings":";;AAAA,SAASA,eAAe,QAAQ,sBAAmB;AACnD,SAASC,YAAY,QAAQ,mBAAgB;AAC7C,SAASC,cAAc,EAAEC,YAAY,EAAEC,WAAW,QAAQ,gBAAa;AAEvE,SACEC,WAAW,EACXC,eAAe,EACfC,kBAAkB,EAClBC,eAAe,EACfC,YAAY,EACZC,gBAAgB,EAChBC,aAAa,EACbC,WAAW,EACXC,iBAAiB,EACjBC,wBAAwB,EACxBC,aAAa,QACR,aAAU","ignoreList":[]}

package/lib/module/proof-of-delivery/shared.js

@@ -0,0 +1,157 @@
+"use strict";
+
+/**
+ * The pure decisions behind the door step: what a stroke looks like as a path,
+ * whether a proof has been given, and what is still missing.
+ *
+ * All of it is exported because none of it can be measured where it is used.
+ * **A jest test cannot see a canvas** — react-native-svg renders to a native
+ * view on one platform and to a `<path>` on the other, and jsdom paints
+ * neither — so the drawing is verified in a real browser
+ * (`scripts/verify-signature-pad.mjs`) and the GEOMETRY is verified here, as a
+ * function of points, where every boundary is reachable: no points, one point,
+ * two, a hundred.
+ */
+import { hairlineOn, surfaceFillOn, surfaceTextOn } from "../styles/surface-levels.js";
+import { PROOF_GEOMETRY, PROOF_ORDER } from "./constants.js";
+export function resolveProofPaint(theme, surface) {
+  const text = surfaceTextOn(theme, surface);
+  const pad = surfaceFillOn(theme, surface);
+  return {
+    surface,
+    hairline: hairlineOn(theme, surface),
+    pad,
+    text: text.text,
+    textSecondary: text.textSecondary,
+    textTertiary: text.textTertiary,
+    padText: surfaceTextOn(theme, pad)
+  };
+}
+
+/** The empty value: nothing drawn, nothing typed, nothing photographed. */
+export const EMPTY_SIGNATURE = {
+  strokes: [],
+  typedName: ''
+};
+export const EMPTY_PROOF = {
+  signature: EMPTY_SIGNATURE,
+  photos: [],
+  code: '',
+  recipient: '',
+  note: ''
+};
+
+/** Fills the gaps in a partial value with the empty one, leaving the rest alone. */
+export function completeProofValue(value) {
+  return {
+    signature: value?.signature ?? EMPTY_SIGNATURE,
+    photos: value?.photos ?? EMPTY_PROOF.photos,
+    code: value?.code ?? '',
+    recipient: value?.recipient ?? '',
+    note: value?.note ?? ''
+  };
+}
+
+/**
+ * One stroke as SVG path data, smoothed.
+ *
+ *   no points     `''` — nothing drawn is not a path of length zero, it is no
+ *                 path at all, and an `<path d="">` is an element the browser
+ *                 still lays out
+ *   one point     a DOT: a zero-length line with a round cap, which is what a
+ *                 full stop in a signature is. Without this a tap lays down
+ *                 nothing and the reader taps harder
+ *   two or more   a move, then a quadratic through the MIDPOINTS of successive
+ *                 points, ending on the last point. Midpoint smoothing is what
+ *                 turns a 60-samples-a-second polyline into something that
+ *                 reads as handwriting; joining the raw points draws the
+ *                 pointer's own stair-stepping
+ *
+ * Coordinates are rounded to two places: a signature does not need a
+ * ten-thousandth of a pixel, and the untrimmed floats triple the size of a
+ * value an app is about to upload.
+ */
+export function signaturePath(stroke) {
+  if (stroke.length === 0) return '';
+  const r = n => Math.round(n * 100) / 100;
+  const first = stroke[0];
+  if (stroke.length === 1) return `M${r(first.x)} ${r(first.y)}l0 0`;
+  let d = `M${r(first.x)} ${r(first.y)}`;
+  for (let i = 1; i < stroke.length - 1; i += 1) {
+    const point = stroke[i];
+    const next = stroke[i + 1];
+    d += `Q${r(point.x)} ${r(point.y)} ${r((point.x + next.x) / 2)} ${r((point.y + next.y) / 2)}`;
+  }
+  const last = stroke[stroke.length - 1];
+  d += `L${r(last.x)} ${r(last.y)}`;
+  return d;
+}
+
+/**
+ * Whether a point is far enough from the last one to be worth keeping.
+ *
+ * A pointer reports the same coordinate many times while a finger rests, and
+ * every repeat is a quadratic segment of length zero that the smoothing then
+ * has to average. Dropping them is what keeps the path proportional to the
+ * MOVEMENT rather than to the duration of the press.
+ */
+export function shouldKeepSignaturePoint(last, point, minDistance = PROOF_GEOMETRY.smoothing) {
+  if (last === undefined) return true;
+  return Math.abs(point.x - last.x) + Math.abs(point.y - last.y) >= minDistance;
+}
+
+/** Whether anything has been drawn. A stroke with no points is not one. */
+export function hasSignatureInk(value) {
+  return (value?.strokes ?? []).some(stroke => stroke.length > 0);
+}
+
+/**
+ * Whether a signature has been GIVEN, by either path.
+ *
+ * Drawn ink and a typed name are the same answer, and this is the one place
+ * that is decided — so a screen-reader user who typed their name is never told
+ * the signature is missing.
+ */
+export function isSignatureGiven(value) {
+  return hasSignatureInk(value) || (value?.typedName ?? '').trim() !== '';
+}
+
+/**
+ * Whether one proof has been given.
+ *
+ * A code counts only once it is FULL: `InputOtp` reports every keystroke, and
+ * "2 of 4 digits" is not a code the recipient read out. `codeLength` is
+ * therefore part of the question rather than something the caller checks after.
+ */
+export function isProofGiven(kind, value, codeLength) {
+  switch (kind) {
+    case 'signature':
+      return isSignatureGiven(value.signature);
+    case 'photo':
+      return value.photos.length > 0;
+    case 'code':
+      return value.code.length >= codeLength;
+    case 'recipient':
+      return value.recipient.trim() !== '';
+    case 'note':
+      return value.note.trim() !== '';
+  }
+}
+
+/**
+ * The required proofs that have not been given, in the order they were asked.
+ *
+ * A proof that is required but NOT DRAWN cannot be missing: an app that asks for
+ * four proofs and requires a fifth it never showed would refuse a delivery over
+ * a control nobody could see. The intersection is taken deliberately, and the
+ * ORDER is the drawn order so the summary reads down the form.
+ */
+export function missingProofs(value, required, shown, codeLength) {
+  return shown.filter(kind => required.includes(kind) && !isProofGiven(kind, value, codeLength));
+}
+
+/** The proofs to draw, in the canonical order, with anything unknown dropped. */
+export function orderProofs(proofs) {
+  return PROOF_ORDER.filter(kind => proofs.includes(kind));
+}
+//# sourceMappingURL=shared.js.map

package/lib/module/proof-of-delivery/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hairlineOn","surfaceFillOn","surfaceTextOn","PROOF_GEOMETRY","PROOF_ORDER","resolveProofPaint","theme","surface","text","pad","hairline","textSecondary","textTertiary","padText","EMPTY_SIGNATURE","strokes","typedName","EMPTY_PROOF","signature","photos","code","recipient","note","completeProofValue","value","signaturePath","stroke","length","r","n","Math","round","first","x","y","d","i","point","next","last","shouldKeepSignaturePoint","minDistance","smoothing","undefined","abs","hasSignatureInk","some","isSignatureGiven","trim","isProofGiven","kind","codeLength","missingProofs","required","shown","filter","includes","orderProofs","proofs"],"sourceRoot":"../../../src","sources":["proof-of-delivery/shared.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/proof-of-delivery/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/proof-of-delivery/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["proof-of-delivery/types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/screen/Screen.js

@@ -6,9 +6,10 @@ import { SafeAreaInsetsContext } from 'react-native-safe-area-context';
 import { windowEdgeGap } from "../layout/edge.js";
 import { useSharedValue } from 'react-native-reanimated';
 import { useTheme } from "../theme/use-theme.js";
-import { WEB_POSITION_STICKY } from "../styles/web-view-style.js";
+import { WEB_POSITION_STICKY, WEB_VIEWPORT_HEIGHT } from "../styles/web-view-style.js";
 import { Z_INDEX } from "../styles/z-index.js";
 import { ScreenContext, ScreenNavigationContext } from "./context.js";
+import { useScreenWindowBinding } from "./use-screen-window-scroll.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** One continuous canvas; chrome overlays it and content reserves its measured footprint. */
 export function Screen({
@@ -62,16 +63,20 @@ export function Screen({
     };
   }, []);
   const hasBottom = !keyboardVisible && Boolean(bottomBar || primaryAction);
+  const document = documentScroll && Platform.OS === 'web';
   const value = useMemo(() => ({
     active,
     scrollY,
     collapseProgress,
     collapseTarget,
     activeScrollerId,
+    contentInsetsHandled: document,
     topInset: header ? top : 0,
     bottomInset: hasBottom ? bottom + contentClearance : navigationScope === 'inherit' ? inheritedNavigation?.bottomInset ?? contentClearance : contentClearance
-  }), [active, scrollY, collapseProgress, collapseTarget, activeScrollerId, header, hasBottom, top, bottom, contentClearance, navigationScope, inheritedNavigation?.bottomInset]);
-  const document = documentScroll && Platform.OS === 'web';
+  }), [active, scrollY, collapseProgress, collapseTarget, activeScrollerId, header, hasBottom, top, bottom, contentClearance, navigationScope, inheritedNavigation?.bottomInset, document]);
+  useScreenWindowBinding(value, {
+    active: document
+  });
   const headerNode = header ? /*#__PURE__*/_jsx(View, {
     testID: testID ? `${testID}-header` : undefined,
     pointerEvents: "box-none",
@@ -125,13 +130,27 @@ export function Screen({
       children: /*#__PURE__*/_jsxs(View, {
         ...props,
         testID: testID,
-        style: [{
+        style: [document ? {
+          minHeight: WEB_VIEWPORT_HEIGHT,
+          width: '100%',
+          position: 'relative',
+          backgroundColor: colors.background
+        } : {
           flex: 1,
           minHeight: 0,
           position: 'relative',
           backgroundColor: colors.background
         }, style],
-        children: [document ? headerNode : null, children, document ? null : headerNode, bottomNode]
+        children: [document ? headerNode : null, document ? /*#__PURE__*/_jsx(View, {
+          testID: testID ? `${testID}-content` : undefined,
+          style: {
+            flexGrow: 1,
+            flexShrink: 0,
+            paddingTop: header ? top : 0,
+            paddingBottom: hasBottom ? bottom + contentClearance : 0
+          },
+          children: children
+        }) : children, document ? null : headerNode, bottomNode]
       })
     })
   });