@bitvea/feedback-toolbar 0.0.1

package/dist/motion.js

@@ -0,0 +1,302 @@
+"use client";
+// The React half of DESIGN.md's `## Motion` section. The values live in
+// tokens.ts, which stays importable without React; what needs hooks lives
+// here.
+//
+// THE RULE, BEFORE YOU ADD THE NEXT ANIMATION. An `opacity` below 1 creates a
+// stacking context, and so does any `transform` - mid-flight included, for
+// every frame the transition is running. So both belong on the element being
+// animated, and never on a wrapper that also holds a surface which has to
+// stack independently or stay opaque. Issue #23 was exactly this: the pin
+// marker's wrapper carried `opacity: 0.45` for a resolved pin, the thread it
+// opened was a child of that wrapper, and the thread therefore painted at 45%
+// with the host page's own table rows reading straight through the card - and
+// its `zIndex` resolved inside the wrapper rather than against `layers` in
+// tokens.ts. A transition is the same defect with a timer on it: it is not
+// enough that the resting state is `opacity: 1`, because the 120ms in between
+// composites the subtree just as hard.
+//
+// The three hooks below are deliberately small and deliberately not an
+// animation library. This bundle ships into a customer's application under a
+// gzip ceiling (CLAUDE.md section 8), and everything here is one transition
+// property away from being CSS.
+import { useEffect, useState, useSyncExternalStore, } from "react";
+import { durationMs, exitFor, motion, motionTransform, REDUCED_MOTION_QUERY, transition, } from "./tokens.js";
+/* ── The reviewer's preference ────────────────────────────────────────── */
+function subscribeReducedMotion(listener) {
+    if (typeof window.matchMedia !== "function")
+        return () => { };
+    const query = window.matchMedia(REDUCED_MOTION_QUERY);
+    query.addEventListener("change", listener);
+    return () => query.removeEventListener("change", listener);
+}
+function prefersReducedMotion() {
+    if (typeof window === "undefined" ||
+        // A host or a test environment with no `matchMedia` at all. Not
+        // hypothetical: jsdom ships without it unless a test adds it, and this
+        // hook runs in every surface below.
+        typeof window.matchMedia !== "function") {
+        return false;
+    }
+    return window.matchMedia(REDUCED_MOTION_QUERY).matches;
+}
+/**
+ * The server's answer, and the hydrating render's: TRUE, no motion.
+ *
+ * The opposite of the light/dark default beside it, and for a different
+ * reason. "Assume light" is a guess at a value; this is a guess at a
+ * PERMISSION, and the safe first paint is the one that moves nothing. It is
+ * also the other half of DESIGN.md's "nothing animates on first mount": a
+ * surface rendered before the media query can be read has no `from` state to
+ * animate out of.
+ */
+function serverPrefersReducedMotion() {
+    return true;
+}
+/**
+ * `prefers-reduced-motion: reduce`, read from the host document and kept live.
+ *
+ * A hook per animating component rather than a field on `ToolbarTheme`. The
+ * theme is a colour and elevation object that `themeFor` returns as one of two
+ * module constants; widening it to carry a motion preference would make it
+ * per-render, which is a real cost for a subscription that is free to
+ * duplicate.
+ */
+export function usePrefersReducedMotion() {
+    return useSyncExternalStore(subscribeReducedMotion, prefersReducedMotion, serverPrefersReducedMotion);
+}
+/* ── Entering ─────────────────────────────────────────────────────────── */
+function noFrameLoop() {
+    return (typeof window === "undefined" ||
+        typeof window.requestAnimationFrame !== "function");
+}
+/**
+ * False on the frame a surface mounts, true on the next one.
+ *
+ * This is the whole reason an inline `transition` is not enough on its own: a
+ * transition never runs on an element's FIRST style computation, so a surface
+ * that mounts already at `opacity: 1` has nothing to transition from. The
+ * `from` state has to be committed, painted, and only then replaced - which is
+ * one `requestAnimationFrame`.
+ *
+ * `requestAnimationFrame` rather than a layout effect that reads `offsetWidth`
+ * to force the same flush. Both work; the reflow version synchronously lays
+ * out the HOST page every time a reviewer opens a thread, and this package's
+ * standing rule is that it costs the page it is injected into as little as
+ * possible. Where there is no frame loop to wait for, the surface simply
+ * starts entered - a hard cut is the correct degradation.
+ *
+ * `settledAtMount` is DESIGN.md's first-mount rule for the one shape that
+ * cannot infer it. For a surface that MOUNTS when it opens, the mount is the
+ * reviewer's own click and there is nothing to distinguish - it enters, which
+ * is the default. For a surface mounted all session and toggled by a prop, an
+ * `active` that is already true on the first render is RESTORED STATE, not an
+ * action: the inbox sheet's open flag comes out of `localStorage`, so without
+ * this the sheet replayed its whole slide-in on every page the reviewer
+ * navigated to with it left open - "the toolbar animates itself in on every
+ * page load", which is the exact thing DESIGN.md forbids.
+ */
+export function useEntered(active = true, settledAtMount = false) {
+    const [entered, setEntered] = useState(() => active && (settledAtMount || noFrameLoop()));
+    // `active` is for a surface whose component is mounted for the whole
+    // session and only shown some of the time - the inbox sheet, which the
+    // toolbar renders unconditionally and toggles with a prop. Mount is the
+    // wrong moment there: it happens on page load, so by the time a reviewer
+    // opens the sheet it has long since "entered" and there is nothing left to
+    // animate. Everything else opens by mounting and takes the default.
+    //
+    // State rather than a ref for the previous value, and not by preference:
+    // `react-hooks/refs` is an error in this repo and reading `.current` during
+    // render is what it forbids. This is the shape `PinLayer` already uses for
+    // its focus request, and React's own documented one for deriving state from
+    // a prop that changed.
+    const [wasActive, setWasActive] = useState(active);
+    if (wasActive !== active) {
+        setWasActive(active);
+        // Re-armed on every activation: a sheet opened twice enters twice.
+        setEntered(noFrameLoop());
+    }
+    useEffect(() => {
+        if (entered || !active)
+            return;
+        const frame = window.requestAnimationFrame(() => setEntered(true));
+        return () => window.cancelAnimationFrame(frame);
+    }, [entered, active]);
+    return entered;
+}
+/**
+ * The two-sided sibling of `useEntered`: false for one frame after `form`
+ * changes, true otherwise, and true on the very first render.
+ *
+ * For a surface that is REPLACED rather than opened. `useEntered` takes a
+ * boolean, so it can only re-arm in one direction - `active` going false means
+ * "this surface is gone" and its effect deliberately stops there. The bar's
+ * two forms (issue #22) are not open and closed: each of them is the current
+ * one, and whichever arrives has to enter, so the trigger is a value CHANGING
+ * rather than a flag going true.
+ *
+ * Settled on the first render, and here that is not an option a call site
+ * passes but the only correct answer: which form the bar is in comes out of
+ * `localStorage`, so a reviewer who collapsed it meets it collapsed on the
+ * next page - restored state, not an action - and a toolbar that replays its
+ * own collapse on every navigation is precisely what DESIGN.md's first-mount
+ * rule forbids. That is the bug `useEntered`'s `settledAtMount` was added for,
+ * one surface earlier.
+ *
+ * THE CALLER MUST REMOUNT THE ELEMENT IT STYLES - key it on the same `form`.
+ * Everything else in this file is used by a surface that mounts when it opens,
+ * which is why a transition can run on it at all: a transition never runs on
+ * an element's FIRST style computation, so the `from` state paints and the
+ * `to` state animates. A swap has no mount, so an element reused across it
+ * receives `opacity: 0` with the transition ALREADY declared, animates 1 -> 0,
+ * and gets reversed one frame later - a hard cut wearing a transition. This
+ * hook decides WHEN the from-state is committed; only a new element makes that
+ * commit instantaneous. See `BarContents` in FeedbackToolbar.tsx.
+ */
+export function useSwapEntered(form) {
+    const [entered, setEntered] = useState(true);
+    // Derived from a prop that changed, during render: React's own documented
+    // shape for this, and the one `react-hooks/refs` leaves available - reading
+    // a ref's `.current` during render is an error in this repo. `useEntered`,
+    // `usePresence` and `useJustChanged` are all built this way.
+    const [seen, setSeen] = useState(form);
+    if (seen !== form) {
+        setSeen(form);
+        // Where there is no frame loop to wait for, the new form is simply already
+        // here: a hard cut is the correct degradation, the same one `useEntered`
+        // takes.
+        setEntered(noFrameLoop());
+    }
+    useEffect(() => {
+        if (entered)
+            return;
+        const frame = window.requestAnimationFrame(() => setEntered(true));
+        return () => window.cancelAnimationFrame(frame);
+    }, [entered]);
+    return entered;
+}
+/**
+ * "Was this one already here when the surface opened?", as a predicate.
+ *
+ * DESIGN.md's first-mount rule applied to a list: the replies already in a
+ * thread are pre-existing state and must not animate, or every reopen of an
+ * old thread replays the whole conversation arriving. Only the reply that
+ * lands while the reviewer is looking is new.
+ *
+ * The set is captured on the first render and never updated, which is the
+ * point - an id that arrives later stays "new" for as long as this surface is
+ * mounted, and the row it belongs to plays its enter exactly once because the
+ * row itself mounts exactly once.
+ */
+export function useNewSinceMount(ids) {
+    // A lazy initialiser rather than a ref filled in on the first render: the
+    // set is captured exactly once either way, and `react-hooks/refs` forbids
+    // touching `.current` during render.
+    const [known] = useState(() => new Set(ids));
+    return (id) => !known.has(id);
+}
+/**
+ * Keep a surface in the DOM for one exit duration after it closes, then take
+ * it out for real.
+ *
+ * The deferral is DOM REMOVAL ONLY. Whatever state change closed the surface
+ * has already been committed by the caller - `openPinId` is null, the sheet's
+ * store says closed - so nothing a reviewer did is waiting on an animation,
+ * which is DESIGN.md's "an exit never delays the action that triggered it".
+ *
+ * And the element really does leave. A surface parked at `opacity: 0` forever
+ * is markup in a host app's DOM that their own queries and audits trip over,
+ * and four e2e specs assert these surfaces reach zero elements - Playwright
+ * retries, so a deferred unmount passes and a permanent ghost does not.
+ *
+ * The latch is set during render rather than in an effect: "a prop changed, so
+ * derive some state from it" is React's own documented shape for this, it is
+ * what `PinLayer` already does for a focus request, and doing it in an effect
+ * would paint one frame of the closed surface still fully open.
+ *
+ * `exit` is the EXIT duration, and a caller that also drives `surfaceMotion`
+ * has to spell it the same way that helper does - `exitFor(<the enter step>)`
+ * - or the timer and the transition are two independent literals for the one
+ * value DESIGN.md calls "exactly the exit duration".
+ */
+export function usePresence(open, exit) {
+    const [leaving, setLeaving] = useState(false);
+    const [wasOpen, setWasOpen] = useState(open);
+    if (wasOpen !== open) {
+        setWasOpen(open);
+        // Re-opening mid-exit cancels the exit, which is the same statement.
+        setLeaving(!open);
+    }
+    useEffect(() => {
+        if (!leaving)
+            return;
+        const timer = window.setTimeout(() => setLeaving(false), durationMs(exit));
+        return () => window.clearTimeout(timer);
+    }, [leaving, exit]);
+    return { mounted: open || leaving, leaving };
+}
+/**
+ * True for one `instant` after `value` changes, and false on first mount.
+ *
+ * For acknowledging a number that moved rather than a surface that arrived:
+ * the unread badge, whose colours and position are identical before and after,
+ * so without this a count going 3 → 4 is a glyph swap nobody sees.
+ *
+ * A latch rather than an enter, and the difference matters: the element has
+ * been on screen for a while, so its resting state is already painted and a
+ * transition out of it runs immediately - no frame of `from` state to arrange,
+ * and therefore no `requestAnimationFrame`.
+ */
+export function useJustChanged(value) {
+    const [changed, setChanged] = useState(false);
+    const [seen, setSeen] = useState(value);
+    if (seen !== value) {
+        setSeen(value);
+        setChanged(true);
+    }
+    useEffect(() => {
+        if (!changed)
+            return;
+        const timer = window.setTimeout(() => setChanged(false), durationMs(motion.duration.instant));
+        return () => window.clearTimeout(timer);
+    }, [changed]);
+    return changed;
+}
+/**
+ * Every entering and leaving surface in this package, styled from one place.
+ *
+ * A helper rather than five hand-written style fragments because "the same
+ * enter everywhere" is the point of having tokens at all, and because the
+ * three things easy to get wrong here - which properties are transitioned,
+ * which direction the easing runs, what reduced motion drops - are exactly the
+ * three a call site would restate slightly differently each time.
+ *
+ * Only `opacity` and `transform` appear. Both are handed to the compositor and
+ * reflow nothing, which is what lets this package animate at all over a host
+ * page nobody here wrote.
+ */
+export function surfaceMotion({ visible, leaving = false, reduced, origin, slide, duration = motion.duration.fast, }) {
+    const shown = visible && !leaving;
+    const offset = slide === "x"
+        ? `translateX(${motion.enterShift})`
+        : slide === "y"
+            ? `translateY(${motion.enterShift})`
+            : `scale(${motion.enterScale})`;
+    return {
+        opacity: shown ? 1 : 0,
+        // Reduced motion keeps the cross-fade and drops the travel: a surface that
+        // has to move is the part of this a vestibular preference is about, and
+        // "it appeared" is information rather than decoration. Both halves of that
+        // are decided in tokens.ts rather than here - see `motionTransform` and
+        // the required `reduced` argument on `transition`.
+        transform: motionTransform(shown ? "none" : offset, reduced),
+        ...(origin === undefined ? {} : { transformOrigin: origin }),
+        transition: transition(["opacity", "transform"], 
+        // One step faster out than in: arriving is information the reader
+        // wants, leaving is a surface getting out of their way. Derived from
+        // the enter rather than pinned to the floor, so the rule holds for the
+        // slow step as well - see `exitFor`.
+        leaving ? exitFor(duration) : duration, leaving ? motion.easing.exit : motion.easing.enter, reduced),
+    };
+}
+//# sourceMappingURL=motion.js.map

package/dist/motion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.js","sourceRoot":"","sources":["../src/motion.ts"],"names":[],"mappings":"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"}

package/dist/preferences.d.ts

@@ -0,0 +1,71 @@
+import { type ToolbarDock } from "./tokens.js";
+/**
+ * Every toolbar setting that belongs to the reviewer rather than to the build.
+ *
+ * Deliberately not widened to "anything a component wants to remember": the
+ * theme and the inbox flag are not here, and the test for admission is whether
+ * a second setting would otherwise want its own key next to this one.
+ */
+export interface ToolbarPreferences {
+    /** Whether the bar is in its collapsed form. Issue #22. */
+    collapsed: boolean;
+    /** Which edge or corner the bar is docked to. Issue #21. */
+    dock: ToolbarDock;
+}
+export declare const TOOLBAR_PREFERENCES_STORAGE_KEY = "bitvea.feedback-toolbar.preferences";
+/**
+ * The answer for a reviewer who has never touched anything, for a host whose
+ * storage cannot be read, and for the server.
+ *
+ * Frozen and shared by identity rather than rebuilt per call, because it is
+ * `getServerSnapshot`'s return value and `useSyncExternalStore` compares
+ * snapshots with `Object.is` - see the note on `readPreferences`.
+ */
+export declare const DEFAULT_PREFERENCES: ToolbarPreferences;
+/**
+ * The reviewer's settings, from storage.
+ *
+ * Memoised on the raw string, and `useSyncExternalStore` is the reason rather
+ * than performance: it compares snapshots with `Object.is` and re-renders
+ * whenever they differ, so a freshly parsed object on every call is an
+ * infinite render loop that React reports as "The result of getSnapshot should
+ * be cached to avoid an infinite loop". The two stores this one is modelled on
+ * return booleans and never had to think about it; a record has to.
+ */
+export declare function readPreferences(): ToolbarPreferences;
+/**
+ * Change some of the record, leaving the rest of what is stored alone.
+ *
+ * Read-merge-write, and the merge is over the STORED keys rather than over
+ * `ToolbarPreferences`. This issue writes `collapsed` and #21 writes `dock`;
+ * either one writing a whole record built from its own fields would erase the
+ * other's the first time a reviewer used both. The same spread is what
+ * preserves a key this build has never heard of.
+ */
+export declare function writePreferences(patch: Partial<ToolbarPreferences>): void;
+/**
+ * The settings as an external store, not as component state read from
+ * `localStorage` in a `useState` initialiser.
+ *
+ * The initialiser is the shape this package already had to fix once, in
+ * `INBOX_OPEN_STORE`: on the server the read answers the default and on the
+ * client it answers the stored value, so a reviewer who had changed anything
+ * got React's "server rendered HTML didn't match the client" in the
+ * CUSTOMER's console on every page load. `collapsed` is a harder case than the
+ * inbox flag was - it decides which CONTROLS EXIST in the bar - so it takes
+ * the same shape: a deterministic server snapshot, and the stored value
+ * adopted after hydration rather than during it.
+ */
+export declare const PREFERENCES_STORE: {
+    subscribe: (listener: () => void) => (() => void);
+    /** The client's answer: storage, else whatever this page last chose. */
+    getSnapshot: typeof readPreferences;
+    /**
+     * The server's answer, and the first client render's. The defaults: a bar
+     * that hydrates in the form the server drew and then adopts the reviewer's
+     * choice is a paint, and one that hydrates into a different set of buttons
+     * than the server rendered is an error in somebody else's application.
+     */
+    getServerSnapshot: () => ToolbarPreferences;
+};
+//# sourceMappingURL=preferences.d.ts.map

package/dist/preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../src/preferences.ts"],"names":[],"mappings":"AAuCA,OAAO,EAA+B,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,SAAS,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,eAAO,MAAM,+BAA+B,wCACL,CAAC;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAGhC,CAAC;AA2EH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,kBAAkB,CAOpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,CASzE;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB;0BAIN,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC;IAM/C,wEAAwE;;IAExE;;;;;OAKG;6BACoB,kBAAkB;CAC1C,CAAC"}

package/dist/preferences.js

@@ -0,0 +1,195 @@
+// What this reviewer did to the toolbar itself, as ONE record under ONE key.
+//
+// Two things about the bar are the reviewer's to decide and have to survive a
+// reload: whether it is collapsed (issue #22) and, next, where it is docked
+// (issue #21). Issue #22 says in as many words that those are "one persisted
+// preference object, not two competing ones", and the reason is not tidiness.
+// Two keys written by two independent toggles are two things that can disagree
+// about what the bar looks like, and the second one added is always the one
+// that forgets the first exists. So this is a RECORD from the first field, and
+// #21 landed exactly the way that promised: one more property on
+// `ToolbarPreferences`, one more line in `parsePreferences`, one more key in
+// the frozen defaults, and the import of the guard that validates it. The
+// read-merge-write and the raw-string memoisation below did not have to move.
+//
+// The two single-valued preferences already in this package stay where they
+// are: `THEME_STORAGE_KEY` in tokens.ts and `INBOX_OPEN_STORAGE_KEY` in
+// InboxSheet.tsx, each read by the store that owns it and each named by a
+// unit test. Neither is what #22 is about, so this file is a new home for new
+// settings rather than a migration - and the key below is deliberately NOT on
+// the package's public surface either, unlike `INBOX_OPEN_STORAGE_KEY`, which
+// index.ts exports because a host replacing the inbox has to be able to read
+// the flag the default one wrote.
+//
+// STORAGE HERE BELONGS TO THE HOST, and all three consequences of that are
+// real failure modes rather than hypotheticals:
+//
+//   - The accessor itself throws. Safari's private mode and a blocked origin
+//     throw on `window.localStorage`, not on `getItem`, so every access sits
+//     inside a `try`. An exception out of this file takes the host
+//     application's render down with it.
+//   - The key sits in the host's own key space, beside whatever they store, so
+//     it is namespaced `bitvea.feedback-toolbar.*` like its two neighbours.
+//   - The VALUE can be anything. It is the host's origin: their code, a
+//     browser extension, or an older or newer build of this toolbar can have
+//     written it. So parsing is defensive per field, and unknown keys are
+//     preserved on write - which is what lets a browser that has already
+//     stored #21's dock keep it through a downgrade to a build that has never
+//     heard of one.
+import { DEFAULT_DOCK, isToolbarDock } from "./tokens.js";
+export const TOOLBAR_PREFERENCES_STORAGE_KEY = "bitvea.feedback-toolbar.preferences";
+/**
+ * The answer for a reviewer who has never touched anything, for a host whose
+ * storage cannot be read, and for the server.
+ *
+ * Frozen and shared by identity rather than rebuilt per call, because it is
+ * `getServerSnapshot`'s return value and `useSyncExternalStore` compares
+ * snapshots with `Object.is` - see the note on `readPreferences`.
+ */
+export const DEFAULT_PREFERENCES = Object.freeze({
+    collapsed: false,
+    dock: DEFAULT_DOCK,
+});
+const listeners = new Set();
+/**
+ * The record as it was last written, when it could not be stored - private
+ * mode, a blocked origin, a host that disabled storage, a full quota. The
+ * choice then holds for this page and no longer, which beats a control that
+ * appears not to work at all.
+ */
+let memoryRaw = null;
+/** The last string parsed, and what it parsed to. See `readPreferences`. */
+let cachedRaw = null;
+let cached = DEFAULT_PREFERENCES;
+function readRaw() {
+    // Memory FIRST, which is one step further than the theme and inbox stores go
+    // - they consult their fallback only when the read throws. A write is what
+    // fails on a full quota or a partially blocked origin: `getItem` keeps
+    // working there and keeps answering the value from before the reviewer's
+    // click, so a storage-first read would honour a preference they had just
+    // replaced. `memoryRaw` is non-null only because a write could not be
+    // stored, and in that case it is the truth for this page.
+    if (memoryRaw !== null)
+        return memoryRaw;
+    try {
+        return window.localStorage.getItem(TOOLBAR_PREFERENCES_STORAGE_KEY);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The stored JSON as a plain object, with every key it happened to carry, or
+ * null for anything that is not one - malformed JSON, a string, a number, an
+ * array. `Array.isArray` is checked separately because an array IS a
+ * `typeof "object"` and spreading one produces index keys.
+ */
+function parseObject(raw) {
+    if (raw === null)
+        return null;
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Per FIELD, and that is the whole of the parsing policy: a stored record with
+ * `collapsed: "yes"` in it falls back to the default for `collapsed` and keeps
+ * whatever else it holds, rather than being thrown away wholesale. With two
+ * fields written by two different issues, discarding the record on one bad
+ * value means one bad write erases the other feature's setting.
+ */
+function parsePreferences(raw) {
+    const stored = parseObject(raw);
+    if (stored === null)
+        return DEFAULT_PREFERENCES;
+    return {
+        collapsed: typeof stored.collapsed === "boolean"
+            ? stored.collapsed
+            : DEFAULT_PREFERENCES.collapsed,
+        // Through the same guard `isThemeMode` is: a dock this build has never
+        // heard of - a newer one's, or a browser extension's - reads back as the
+        // default rather than as a value the layout table has no row for. The
+        // stored string itself survives, because the write below merges over the
+        // STORED keys and never over this record.
+        dock: isToolbarDock(stored.dock) ? stored.dock : DEFAULT_PREFERENCES.dock,
+    };
+}
+/**
+ * The reviewer's settings, from storage.
+ *
+ * Memoised on the raw string, and `useSyncExternalStore` is the reason rather
+ * than performance: it compares snapshots with `Object.is` and re-renders
+ * whenever they differ, so a freshly parsed object on every call is an
+ * infinite render loop that React reports as "The result of getSnapshot should
+ * be cached to avoid an infinite loop". The two stores this one is modelled on
+ * return booleans and never had to think about it; a record has to.
+ */
+export function readPreferences() {
+    const raw = readRaw();
+    if (raw !== cachedRaw) {
+        cachedRaw = raw;
+        cached = parsePreferences(raw);
+    }
+    return cached;
+}
+/**
+ * Change some of the record, leaving the rest of what is stored alone.
+ *
+ * Read-merge-write, and the merge is over the STORED keys rather than over
+ * `ToolbarPreferences`. This issue writes `collapsed` and #21 writes `dock`;
+ * either one writing a whole record built from its own fields would erase the
+ * other's the first time a reviewer used both. The same spread is what
+ * preserves a key this build has never heard of.
+ */
+export function writePreferences(patch) {
+    const raw = JSON.stringify({ ...(parseObject(readRaw()) ?? {}), ...patch });
+    try {
+        window.localStorage.setItem(TOOLBAR_PREFERENCES_STORAGE_KEY, raw);
+        memoryRaw = null;
+    }
+    catch {
+        memoryRaw = raw;
+    }
+    listeners.forEach((listener) => listener());
+}
+/**
+ * The settings as an external store, not as component state read from
+ * `localStorage` in a `useState` initialiser.
+ *
+ * The initialiser is the shape this package already had to fix once, in
+ * `INBOX_OPEN_STORE`: on the server the read answers the default and on the
+ * client it answers the stored value, so a reviewer who had changed anything
+ * got React's "server rendered HTML didn't match the client" in the
+ * CUSTOMER's console on every page load. `collapsed` is a harder case than the
+ * inbox flag was - it decides which CONTROLS EXIST in the bar - so it takes
+ * the same shape: a deterministic server snapshot, and the stored value
+ * adopted after hydration rather than during it.
+ */
+export const PREFERENCES_STORE = {
+    // Arrow properties rather than shorthand methods: these are handed to
+    // `useSyncExternalStore` detached from the object, so nothing here may
+    // depend on `this`.
+    subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    },
+    /** The client's answer: storage, else whatever this page last chose. */
+    getSnapshot: readPreferences,
+    /**
+     * The server's answer, and the first client render's. The defaults: a bar
+     * that hydrates in the form the server drew and then adopts the reviewer's
+     * choice is a paint, and one that hydrates into a different set of buttons
+     * than the server rendered is an error in somebody else's application.
+     */
+    getServerSnapshot: () => DEFAULT_PREFERENCES,
+};
+//# sourceMappingURL=preferences.js.map

package/dist/preferences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.js","sourceRoot":"","sources":["../src/preferences.ts"],"names":[],"mappings":"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"}

package/dist/rasterise.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rasterise the visible viewport to a PNG data URL, or null if the browser
+ * would not produce one.
+ *
+ * @param maxDataUrlLength Longest data URL the API will accept. The image is
+ *   re-encoded at half scale, twice, before giving up, so a very large or very
+ *   dense viewport degrades in quality rather than disappearing.
+ */
+export declare function rasteriseViewport(maxDataUrlLength: number): Promise<string | null>;
+/**
+ * Rasterise ONE element to a PNG data URL, or null if the browser would not
+ * produce one.
+ *
+ * A reviewer pointing at a broken button wants a picture of the button, not of
+ * the page it is on: the whole-viewport shot puts the thing they are reporting
+ * somewhere in a 1512x916 image and leaves the reader to find it. This is the
+ * camera in the composer.
+ *
+ * An element with no box - `display: none`, or detached - yields null rather
+ * than a 1x1 image, because a blank attachment is worse than none.
+ */
+export declare function rasteriseElement(element: Element, maxDataUrlLength: number): Promise<string | null>;
+/**
+ * Serialise the visible page as an SVG document string, or null if the page is
+ * too large to walk. Exported for the unit tests: it is pure DOM work with no
+ * canvas or image decoding in it, so it is the part that is provable in jsdom.
+ */
+export declare function buildViewportSvg(width: number, height: number, 
+/**
+ * Where in the viewport the picture starts. `{x: 0, y: 0}` is the viewport
+ * shot; an element shot passes its own top-left, and the body clone shifts
+ * by the same amount so the element lands at the picture's origin.
+ *
+ * Cropping by MOVING THE WHOLE PAGE rather than by cloning only the element
+ * is the decision here. An element does not carry its own layout: its width
+ * may come from a flex parent, its colour from a `.dark` ancestor, its font
+ * from `html`. Cloning it alone reproduces none of that, and the picture
+ * that comes back is not the thing the reviewer pointed at. The page is
+ * cloned exactly as it is and the viewport is narrowed instead.
+ */
+origin?: {
+    x: number;
+    y: number;
+}): string | null;
+//# sourceMappingURL=rasterise.d.ts.map

package/dist/rasterise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterise.d.ts","sourceRoot":"","sources":["../src/rasterise.ts"],"names":[],"mappings":"AAgNA;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAExB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIxB;AAsDD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM;AACd;;;;;;;;;;;GAWG;AACH,MAAM,GAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAmB,GAChD,MAAM,GAAG,IAAI,CAyCf"}