@usableapp/cardds 0.7.84 → 0.7.86

package/dist/index.d.ts

@@ -81,6 +81,7 @@ export * from './sticky/StickyField.js';
 export * from './sticky/StickyPick.js';
 export * from './sticky/StickyThread.js';
 export * from './sticky/StickyBoard.js';
+export * from './sticky/StickyPile.js';
 export * from './sticky/StickyAnswer.js';
 export * from './stamp/Stamp.js';
 export * from './stamp/StampBook.js';

package/dist/index.js

@@ -85,6 +85,7 @@ export * from './sticky/StickyField.js';
 export * from './sticky/StickyPick.js';
 export * from './sticky/StickyThread.js';
 export * from './sticky/StickyBoard.js';
+export * from './sticky/StickyPile.js';
 export * from './sticky/StickyAnswer.js';
 export * from './stamp/Stamp.js';
 export * from './stamp/StampBook.js';

package/dist/stamp/StampOn.d.ts

@@ -15,12 +15,36 @@ export interface StampOnProps extends ComponentProps<'div'> {
     onAtChange?: (at: StampAt) => void;
     /** a draggable stamp's accessible name ("แสตมป์ของต้น") */
     label?: string;
+    /** the stamp can be TAKEN OFF: when a drag ends, an arrow key moves it, or (on a stamp that cannot be dragged) it is pressed, a cross stands on its top right corner for `removeFor` ms; a press on the cross — or Delete / Backspace on the focused stamp — ASKS. The app owns what is stuck (as it owns `at`): it takes the `StampOn` away. Without it nothing changes: no cross, the stamp is dragged as before and cannot be taken off. A press or a drag on a removable stamp never reaches what lies under it */
+    onRemove?: () => void;
+    /** the cross's accessible name (default: cardds's own word, "Remove" / "เอาออก" by the page's language) */
+    removeLabel?: string;
+    /** how long the cross stands after the stamp was touched, in ms (default 3000). It stays while it holds the keyboard focus; a new drag takes it away until the drag ends */
+    removeFor?: number;
+    /** the stamp at the stamp's MAIN size, 96 × 120 (`--stamp-size`), to cover what it lies on; the default is the small size, 48 × 60 (`--stamp-sm-size`), which leaves a note's words readable */
+    main?: boolean;
+    /** the stamp sticks ITSELF: as it comes onto the screen it is struck onto its place (shown large, pressed down to its size). Nobody
+     *  picked it or pressed to stick it — the app shows it when its own move (send) begins. With `onArrived` */
+    arrive?: boolean;
+    /** an arriving stamp has LANDED (its strike ended; at once where motion is off) — the app does what follows: sends, closes */
+    onArrived?: () => void;
 }
 /**
  * StampOn — a Stamp (the child) stuck on a surface at the place the member chose. The surface is the nearest positioned box:
  * a Sticky's `stuck`, a postcard's face. `at` is the stamp's middle as a share of that surface, so the note reads the same at any size.
- * The stamp is the SMALL size: 48 × 60 on any surface, whatever the surface's size (`--stamp-sm-size`, one tap wide).
+ * The stamp is the SMALL size: 48 × 60 on any surface, whatever the surface's size (`--stamp-sm-size`, one tap wide); `main` makes it the
+ * stamp's main size, 96 × 120, to cover what it lies on.
  * With `onAtChange` the member drags it (finger or mouse; the arrow keys move it too): while the finger holds, the stamp writes its
  * own place, and on letting go it ASKS — the app owns `at`. It never leaves the surface.
+ * With `onRemove` it can be taken off: once touched (a drag let go, an arrow key, or a press on a stamp that cannot be dragged) a cross
+ * stands on its top right corner for `removeFor` ms; a press on the cross, or Delete / Backspace on the focused stamp, ASKS, and the app
+ * takes the stamp away. `onRemove` without `onAtChange` is a stamp that stays where it is and is taken off: a press shows the cross
+ * (a warning instead would leave the prop dead, since the cross needs a touch to appear). A press or a drag on a removable stamp or its
+ * cross stops there, so a pressable card or pile under it is not pressed. The cross stays upright whatever the stamp's `turn`: it is a
+ * button, and its 44 × 44 touch target round the 24 disc should be square to the screen.
+ * Inside a `StickyPile`, a stamp on a note under the top one is inert: no drag, no cross, no focus.
+ * With `arrive` it sticks itself: struck onto its place as it comes on, and `onArrived` tells the app it has landed. A stamp that is still
+ * arriving cannot be taken off: no cross, no focus, no Delete until it has landed (it is not stuck yet). `arrive` with `main` strikes
+ * the main size, 96 × 120, onto its place.
  */
-export declare function StampOn({ at, defaultAt, turn, onAtChange, label, className, style, children, ...rest }: StampOnProps): import("react").JSX.Element;
+export declare function StampOn({ at, defaultAt, turn, onAtChange, label, onRemove, removeLabel, removeFor, main, arrive, onArrived, className, style, onAnimationEnd, children, ...rest }: StampOnProps): import("react").JSX.Element;

package/dist/stamp/StampOn.js

@@ -1,7 +1,10 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useRef, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useEffect, useRef, useState } from 'react';
 import { cx } from '../cx.js';
-import { useControlled } from '../state.js';
+import { reducedMotion, useControlled } from '../state.js';
+import { Icon } from '../type/Icon.js';
+import { word } from '../words.js';
+import { UnderNotes } from './underNotes.js';
 const MIDDLE = { x: 0.5, y: 0.5 };
 const STEP = 0.02; // an arrow key's move: a share of the surface
 const MOVES = { ArrowLeft: [-STEP, 0], ArrowRight: [STEP, 0], ArrowUp: [0, -STEP], ArrowDown: [0, STEP] };
@@ -15,21 +18,42 @@ function within(el, x, y) {
     const mx = el.offsetWidth / 2 / box.clientWidth, my = el.offsetHeight / 2 / box.clientHeight;
     return { x: round(clamp(x, mx, 1 - mx)), y: round(clamp(y, my, 1 - my)) };
 }
+const STRIKE = 'stamp-on-strike'; // css/stamp.css
 const write = (el, at) => { el.style.setProperty('--stamp-on-x', String(at.x)); el.style.setProperty('--stamp-on-y', String(at.y)); };
 /**
  * StampOn — a Stamp (the child) stuck on a surface at the place the member chose. The surface is the nearest positioned box:
  * a Sticky's `stuck`, a postcard's face. `at` is the stamp's middle as a share of that surface, so the note reads the same at any size.
- * The stamp is the SMALL size: 48 × 60 on any surface, whatever the surface's size (`--stamp-sm-size`, one tap wide).
+ * The stamp is the SMALL size: 48 × 60 on any surface, whatever the surface's size (`--stamp-sm-size`, one tap wide); `main` makes it the
+ * stamp's main size, 96 × 120, to cover what it lies on.
  * With `onAtChange` the member drags it (finger or mouse; the arrow keys move it too): while the finger holds, the stamp writes its
  * own place, and on letting go it ASKS — the app owns `at`. It never leaves the surface.
+ * With `onRemove` it can be taken off: once touched (a drag let go, an arrow key, or a press on a stamp that cannot be dragged) a cross
+ * stands on its top right corner for `removeFor` ms; a press on the cross, or Delete / Backspace on the focused stamp, ASKS, and the app
+ * takes the stamp away. `onRemove` without `onAtChange` is a stamp that stays where it is and is taken off: a press shows the cross
+ * (a warning instead would leave the prop dead, since the cross needs a touch to appear). A press or a drag on a removable stamp or its
+ * cross stops there, so a pressable card or pile under it is not pressed. The cross stays upright whatever the stamp's `turn`: it is a
+ * button, and its 44 × 44 touch target round the 24 disc should be square to the screen.
+ * Inside a `StickyPile`, a stamp on a note under the top one is inert: no drag, no cross, no focus.
+ * With `arrive` it sticks itself: struck onto its place as it comes on, and `onArrived` tells the app it has landed. A stamp that is still
+ * arriving cannot be taken off: no cross, no focus, no Delete until it has landed (it is not stuck yet). `arrive` with `main` strikes
+ * the main size, 96 × 120, onto its place.
  */
-export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, className, style, children, ...rest }) {
+export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, onRemove, removeLabel, removeFor = 3000, main, arrive, onArrived, className, style, onAnimationEnd, children, ...rest }) {
+    const under = useContext(UnderNotes);
     const [shown, request] = useControlled(at, defaultAt, onAtChange);
     const [held, setHeld] = useState(false);
+    const [cross, setCross] = useState(false);
     const grip = useRef(null);
-    const moves = onAtChange != null;
+    const timer = useRef(undefined);
+    const moves = onAtChange != null && !under;
+    const [arrived, setArrived] = useState(false);
+    const removes = onRemove != null && !under && !(arrive && !arrived);
     const ask = (next) => { if (next.x !== shown.x || next.y !== shown.y)
         request(next); };
+    const stop = () => clearTimeout(timer.current);
+    const show = () => { if (!removes)
+        return; stop(); setCross(true); timer.current = setTimeout(() => setCross(false), removeFor); };
+    useEffect(() => stop, []);
     const down = (e) => {
         const el = e.currentTarget, box = el.offsetParent;
         if (!box || e.button !== 0)
@@ -38,6 +62,8 @@ export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, c
         grip.current = { dx: (e.clientX - r.left - box.clientLeft) / box.clientWidth - shown.x, dy: (e.clientY - r.top - box.clientTop) / box.clientHeight - shown.y, next: shown };
         el.setPointerCapture(e.pointerId);
         setHeld(true);
+        stop();
+        setCross(false); // a new drag takes the cross away until it ends
     };
     const move = (e) => {
         const el = e.currentTarget, box = el.offsetParent, g = grip.current;
@@ -54,17 +80,59 @@ export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, c
         grip.current = null;
         setHeld(false);
         write(e.currentTarget, shown); // back to what the app has: if it takes the new place, the next render writes it
-        if (e.type === 'pointerup')
+        if (e.type === 'pointerup') {
             ask(g.next);
+            show();
+        }
     };
     const key = (e) => {
-        const by = MOVES[e.key];
-        if (!by)
-            return;
-        e.preventDefault();
-        ask(within(e.currentTarget, shown.x + by[0], shown.y + by[1]));
+        if (e.target !== e.currentTarget)
+            return; // the cross has its own keys
+        const by = moves ? MOVES[e.key] : undefined;
+        if (by) {
+            e.preventDefault();
+            e.stopPropagation();
+            ask(within(e.currentTarget, shown.x + by[0], shown.y + by[1]));
+            show();
+        }
+        else if (removes && (e.key === 'Delete' || e.key === 'Backspace')) {
+            e.preventDefault();
+            e.stopPropagation();
+            stop();
+            setCross(false);
+            onRemove();
+        }
+        else if (removes && !moves && (e.key === 'Enter' || e.key === ' ')) {
+            e.preventDefault();
+            e.stopPropagation();
+            show();
+        }
+    };
+    // nothing that starts on a removable stamp or its cross reaches what lies under it: a click is the end of a press, and a drag's end is one too
+    const click = (e) => {
+        e.stopPropagation();
+        rest.onClick?.(e);
+        if (!moves)
+            show();
+    };
+    const landed = useRef(onArrived);
+    landed.current = onArrived;
+    const land = () => { setArrived(true); landed.current?.(); };
+    useEffect(() => { if (!arrive)
+        setArrived(false);
+    else if (reducedMotion()) {
+        setArrived(true);
+        landed.current?.();
+    } }, [arrive]); // no strike to wait for
+    const struck = (e) => {
+        onAnimationEnd?.(e);
+        if (arrive && e.target === e.currentTarget && e.animationName === STRIKE)
+            land();
     };
     const place = { '--stamp-on-x': shown.x, '--stamp-on-y': shown.y, '--stamp-on-turn': turn, ...style };
-    const drag = moves ? { tabIndex: 0, role: 'group', 'aria-label': label, onPointerDown: down, onPointerMove: move, onPointerUp: up, onPointerCancel: up, onKeyDown: key } : null;
-    return (_jsx("div", { className: cx('stamp-on', moves && 'stamp-on--move', held && 'is-held', className), style: place, ...rest, ...drag, children: children }));
+    const own = moves || removes ? { tabIndex: 0, role: 'group', 'aria-label': label, onKeyDown: key } : null;
+    const drag = moves ? { onPointerDown: down, onPointerMove: move, onPointerUp: up, onPointerCancel: up } : null;
+    const guard = removes ? { onClick: click } : null;
+    return (_jsxs("div", { className: cx('stamp-on', moves && 'stamp-on--move', main && 'stamp-on--main', arrive && 'stamp-on--arrive', held && 'is-held', className), style: place, onAnimationEnd: struck, ...rest, ...own, ...drag, ...guard, inert: under || undefined, children: [children, removes && cross && (_jsx("button", { type: "button", className: "stamp-on__remove", "aria-label": removeLabel ?? word('remove'), onPointerDown: (e) => e.stopPropagation(), onClick: (e) => { e.stopPropagation(); stop(); setCross(false); onRemove(); }, onFocus: stop, onBlur: () => { if (!grip.current)
+                    show(); }, children: _jsx("span", { className: "stamp-on__remove-disc", children: _jsx(Icon, { name: "x" }) }) }))] }));
 }

package/dist/stamp/underNotes.d.ts

@@ -0,0 +1,3 @@
+/** set by a holder whose notes lie one under another (`StickyPile`): a stamp on a note that only shows what peeks out is inert — no drag, no cross, no focus.
+ *  Not part of the package's API: a holder writes it, `StampOn` reads it. */
+export declare const UnderNotes: import("react").Context<boolean>;

package/dist/stamp/underNotes.js

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+/** set by a holder whose notes lie one under another (`StickyPile`): a stamp on a note that only shows what peeks out is inert — no drag, no cross, no focus.
+ *  Not part of the package's API: a holder writes it, `StampOn` reads it. */
+export const UnderNotes = createContext(false);

package/dist/sticky/Sticky.d.ts

@@ -13,13 +13,13 @@ export interface StickyProps extends Omit<ComponentProps<'div'>, 'onClick'> {
     head?: ReactNode;
     /** a StickyDate at the end of the head — the note's top-right corner */
     date?: ReactNode;
-    /** turned a little on its middle (the one note of a start screen); a note is straight otherwise, unless its holder turns it (`StickyBoard`, `StickyThread lapped`) */
+    /** turned a little on its middle (the one note of a start screen); a note is straight otherwise, unless its holder turns it (`StickyBoard`, `StickyPile`, `StickyThread lapped`) */
     tilt?: 'left' | 'right';
     /** a small muted line at the bottom ("From …") */
     foot?: ReactNode;
     /** a control (an IconBtn) standing on the bottom-right corner, half outside the note; the note then has no fold */
     corner?: ReactNode;
-    /** things stuck ON the note, each placing itself over the paper (a `StampOn`) — a layer the size of the note, in front of the words */
+    /** things stuck ON the note, each placing itself over the paper (a `StampOn`: the small stamp, or `main` for the main size) — a layer the size of the note, in front of the words */
     stuck?: ReactNode;
 }
 /**

package/dist/sticky/StickyPile.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentProps } from 'react';
+export interface StickyPileProps extends Omit<ComponentProps<'div'>, 'onClick'> {
+    /** the whole pile is ONE button: it renders a `<button>` over the notes and says that it was pressed — one note or many, and where the press goes, is the app's. Without it the pile only shows. A `Sticky` inside with an `onClick` of its own is misuse (two buttons for one pile): the pile warns once */
+    onClick?: () => void;
+    /** the pile's accessible name, REQUIRED with `onClick` (the notes' words are not read by the button): say how many and from whom, in the app's words. Warns once without it */
+    label?: string;
+}
+/**
+ * StickyPile — ONE to SIX `Sticky` notes lying one over another, as the newest notes of a feed do. The FIRST child is on top (the app passes
+ * the newest first); each note under it is shifted a step right and down, so a strip of it peeks out (`--sticky-pile-step-x`, 24, and
+ * `--sticky-pile-step-y`, 8) and turned a little by the same four angles as `StickyBoard` (−3° · 1.5° · 2.75° · −1.75°, by the child's place,
+ * so the top note's turn is the same whether the pile holds one note or six). Only the top note draws its `foot`: a cut time under another note is
+ * noise. A pile of one is that note, centred, with its foot. A seventh note is not drawn (a warning, once).
+ * The pile is centred in its column and never wider than it: a column too narrow for the steps shortens them (a lone note's width is the least it takes).
+ * It knows nothing of a feed or a home: in a Home's `base` it stands above a `CardFeed`, and the app writes both.
+ * With `onClick` the whole pile is one control with a name (`label`): one Tab stop, a ring round the pile, dimmed while it is held.
+ * A `StampOn` on the TOP note keeps its own touch — dragging it, or pressing its cross, never presses the pile — and the stamps on the notes under it are inert
+ * (no drag, no cross, no focus: they only show what peeks out), whatever the app passed.
+ */
+export declare function StickyPile({ onClick, label, className, style, children, ...rest }: StickyPileProps): import("react").JSX.Element;

package/dist/sticky/StickyPile.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Children, isValidElement } from 'react';
+import { cx } from '../cx.js';
+import { warnOnce } from '../state.js';
+import { UnderNotes } from '../stamp/underNotes.js';
+/** most notes a pile draws; a seventh is dropped, as a Stamp drops a fifth picture */
+const MOST = 6;
+/**
+ * StickyPile — ONE to SIX `Sticky` notes lying one over another, as the newest notes of a feed do. The FIRST child is on top (the app passes
+ * the newest first); each note under it is shifted a step right and down, so a strip of it peeks out (`--sticky-pile-step-x`, 24, and
+ * `--sticky-pile-step-y`, 8) and turned a little by the same four angles as `StickyBoard` (−3° · 1.5° · 2.75° · −1.75°, by the child's place,
+ * so the top note's turn is the same whether the pile holds one note or six). Only the top note draws its `foot`: a cut time under another note is
+ * noise. A pile of one is that note, centred, with its foot. A seventh note is not drawn (a warning, once).
+ * The pile is centred in its column and never wider than it: a column too narrow for the steps shortens them (a lone note's width is the least it takes).
+ * It knows nothing of a feed or a home: in a Home's `base` it stands above a `CardFeed`, and the app writes both.
+ * With `onClick` the whole pile is one control with a name (`label`): one Tab stop, a ring round the pile, dimmed while it is held.
+ * A `StampOn` on the TOP note keeps its own touch — dragging it, or pressing its cross, never presses the pile — and the stamps on the notes under it are inert
+ * (no drag, no cross, no focus: they only show what peeks out), whatever the app passed.
+ */
+export function StickyPile({ onClick, label, className, style, children, ...rest }) {
+    const all = Children.toArray(children).filter((c) => isValidElement(c));
+    if (all.length > MOST)
+        warnOnce('sticky-pile-most', `cardds StickyPile: ${all.length} notes — at most six are drawn; show the rest elsewhere`);
+    const notes = all.slice(0, MOST);
+    const tap = onClick != null;
+    if (tap && label == null)
+        warnOnce('sticky-pile-label', 'cardds StickyPile: onClick without a label — the pile is one button and the notes\' words are not its name');
+    if (tap && notes.some((n) => n.props.onClick != null))
+        warnOnce('sticky-pile-tap', 'cardds StickyPile: a Sticky with its own onClick inside a pile that has one — two buttons for one pile; give the pile the onClick');
+    return (_jsx("div", { className: cx('sticky-pile', tap && 'sticky-pile--tap', className), style: { '--_n': notes.length, ...style }, ...rest, children: _jsxs("div", { className: "sticky-pile__notes", children: [notes.map((note, i) => _jsx(UnderNotes.Provider, { value: i > 0, children: note }, note.key)), tap && _jsx("button", { type: "button", className: "sticky-pile__press", "aria-label": label, onClick: onClick })] }) }));
+}

package/dist/words.d.ts

@@ -1,4 +1,4 @@
-export type WordKey = 'resize' | 'back' | 'next' | 'previous' | 'skip' | 'digit' | 'progress' | 'image' | 'mood' | 'photos' | 'voiceNote' | 'play' | 'pause' | 'to' | 'turnToBack' | 'turnToPicture' | 'message' | 'address' | 'toMessage' | 'toAddress' | 'stampOn' | 'stampOff' | 'stamps' | 'unread';
+export type WordKey = 'resize' | 'back' | 'next' | 'previous' | 'skip' | 'digit' | 'progress' | 'image' | 'mood' | 'photos' | 'voiceNote' | 'play' | 'pause' | 'to' | 'turnToBack' | 'turnToPicture' | 'message' | 'address' | 'toMessage' | 'toAddress' | 'stampOn' | 'stampOff' | 'stamps' | 'unread' | 'remove';
 type Words = Record<WordKey, string>;
 /** add or retune the words for a language (`'lo'`, or `'th'` to change one) — once, at app start. Missing words fall back to English. */
 export declare function setWords(lang: string, words: Partial<Words>): void;

package/dist/words.js

@@ -1,8 +1,8 @@
 const sets = {
     en: { resize: 'Resize', back: 'Back', next: 'Next', previous: 'Previous', skip: 'Skip', digit: 'Digit', progress: 'Progress', image: 'Image', mood: 'Mood', photos: 'Photos', voiceNote: 'Voice note',
-        play: 'Play', pause: 'Pause', to: 'To', turnToBack: 'See the back', turnToPicture: 'See the picture', message: 'Message', address: 'Address', toMessage: 'Back to the message', toAddress: 'On to the address', stampOn: 'Stick a stamp', stampOff: 'Take the stamp off', stamps: 'Choose a stamp', unread: 'Unread' },
+        play: 'Play', pause: 'Pause', to: 'To', turnToBack: 'See the back', turnToPicture: 'See the picture', message: 'Message', address: 'Address', toMessage: 'Back to the message', toAddress: 'On to the address', stampOn: 'Stick a stamp', stampOff: 'Take the stamp off', stamps: 'Choose a stamp', unread: 'Unread', remove: 'Remove' },
     th: { resize: 'ปรับความสูง', back: 'กลับ', next: 'ถัดไป', previous: 'ก่อนหน้า', skip: 'ข้าม', digit: 'หลักที่', progress: 'ความคืบหน้า', image: 'รูปภาพ', mood: 'อารมณ์', photos: 'รูปภาพ', voiceNote: 'ข้อความเสียง',
-        play: 'ฟังเสียง', pause: 'หยุดเสียง', to: 'ถึง', turnToBack: 'พลิกดูด้านหลัง', turnToPicture: 'พลิกดูรูป', message: 'ข้อความ', address: 'จ่าหน้า', toMessage: 'เลื่อนกลับไปข้อความ', toAddress: 'เลื่อนไปจ่าหน้า', stampOn: 'ติดแสตมป์', stampOff: 'แกะแสตมป์ออก', stamps: 'เลือกแสตมป์', unread: 'ยังไม่ได้อ่าน' },
+        play: 'ฟังเสียง', pause: 'หยุดเสียง', to: 'ถึง', turnToBack: 'พลิกดูด้านหลัง', turnToPicture: 'พลิกดูรูป', message: 'ข้อความ', address: 'จ่าหน้า', toMessage: 'เลื่อนกลับไปข้อความ', toAddress: 'เลื่อนไปจ่าหน้า', stampOn: 'ติดแสตมป์', stampOff: 'แกะแสตมป์ออก', stamps: 'เลือกแสตมป์', unread: 'ยังไม่ได้อ่าน', remove: 'เอาออก' },
 };
 /** add or retune the words for a language (`'lo'`, or `'th'` to change one) — once, at app start. Missing words fall back to English. */
 export function setWords(lang, words) {

package/lint/rules.mjs

@@ -12,7 +12,7 @@ const CSS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'css');
 /** the props whose default is cardds's own word (src/words.ts), per component — a `label` that is a control's required accessible name (IconBtn, Fab, Pin…) is not here */
 export const CONTROL_NAMES = {
   Sheet: ['handle'], CallSheet: ['handle'], StackSheet: ['backLabel'], Home: ['backLabel'], Walkthrough: ['backLabel', 'nextLabel'],
-  Calendar: ['prevLabel', 'nextLabel'], SheetStep: ['skipLabel'], Sticky: ['unreadLabel'], PostLetter: ['backLabel', 'pictureLabel', 'playLabel', 'pauseLabel', 'toLabel'],
+  Calendar: ['prevLabel', 'nextLabel'], SheetStep: ['skipLabel'], Sticky: ['unreadLabel'], StampOn: ['removeLabel'], PostLetter: ['backLabel', 'pictureLabel', 'playLabel', 'pauseLabel', 'toLabel'],
 };
 
 const lineOf = (text, idx) => text.slice(0, idx).split('\n').length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usableapp/cardds",
-  "version": "0.7.84",
+  "version": "0.7.86",
   "license": "UNLICENSED",
   "type": "module",
   "description": "card-first mobile design system, React-first: the components in src/ are thin wrappers over the CSS contract (css/*.css stays the only truth); gallery/ shows every story live (npm run dev), tests/ measures the geometry.",