@nanisoft/prism-ui 0.13.0 → 0.15.0

package/dist/blocks/compliance-01/compliance.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { Section, SectionHeading } from '../../components/ui/section.js';
+import { Status } from '../../components/ui/status.js';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from '../../components/ui/table.js';
+/**
+ * The tone each state is drawn in.
+ *
+ * Mapped rather than passed, because `Status` owns the tones and a Block that
+ * let a caller pick one would be handing out five judgements about somebody
+ * else's regulatory position. `in-progress` is `info` rather than `warning`
+ * because a standard being worked toward is the ordinary state of a compliance
+ * programme and not an alarm; `not-applicable` is `neutral` because it is the
+ * state with nothing to alarm about, which is exactly what `Status` says `neutral`
+ * is for.
+ */
+const STATE_TONE = {
+    held: 'success',
+    'in-progress': 'info',
+    'not-applicable': 'neutral',
+};
+/**
+ * The two refusals, as checks, so that a claim Prism cannot justify is a
+ * diagnostic in a console rather than a rendered row.
+ *
+ * A `held` claim with no standard throws because a tick beside an assertion with
+ * nothing behind it is the single worst thing this Block could render: it is a
+ * certification mark for a claim that names no standard, which is precisely the
+ * render a design system is most tempted to ship and is the one this Item exists
+ * to refuse. An `in-progress` or `not-applicable` claim with no standard is
+ * allowed, because both of those are statements about work rather than
+ * attestations, and a statement about work does not need a standard behind it.
+ *
+ * An `evidenceHref` with a blank label throws for the reason `Status` states for
+ * its own label: the link would be announced by its address, which is a link no
+ * reader can follow.
+ */
+function assertRow(row) {
+    if (row.state === 'held' && (row.standard === undefined || row.standard.trim() === '')) {
+        throw new Error('Compliance01: a row is in the held state and names no standard, so the state mark would be a bare tick ' +
+            'for a claim nobody has checked against anything. Name the standard, or put the row in the in-progress or ' +
+            'not-applicable state, which is a statement about work rather than an attestation.');
+    }
+    if (row.state !== undefined && (row.stateLabel === undefined || row.stateLabel.trim() === '')) {
+        throw new Error('Compliance01: a row declares a state and no words for it, so the state would be a colour with nothing to ' +
+            'read beside it. Pass stateLabel in the vocabulary the publisher uses, which is not this Block choice.');
+    }
+    if (row.evidenceHref !== undefined && row.evidenceLabel.trim() === '') {
+        throw new Error('Compliance01: a row declares an evidenceHref and an empty evidenceLabel, so the link would be announced by ' +
+            'its address, which is punctuation rather than a name. Pass the words that say which document it is.');
+    }
+}
+/**
+ * A table of what is claimed, to which standard, by whom, when it was last
+ * reviewed, and where the evidence is.
+ *
+ * **The reason this Item exists is not the table.** A table is `Table`, and
+ * `Table` is already in this package. What a design system is tempted to do on a
+ * compliance surface is render a tick for a claim nobody has checked: the tick
+ * is the reward, it is the thing the marketing copy reaches for, and every
+ * design system that has shipped a compliance section has shipped one by
+ * defaulting the state to the good one. So this Block ships a state set in which
+ * the honest answers are first class rather than absent. `in-progress` and
+ * `not-applicable` are members of the set, not edge cases, which is what stops a
+ * publisher from reading the two tone-less states as an admission they have to
+ * hide by claiming the first one instead. And a row that claims to hold something
+ * with no standard behind it throws rather than rendering a bare tick, because
+ * the alternative is a certification mark this package drew for a sentence it
+ * cannot check.
+ *
+ * **Every word in every cell is the caller's legal statement.** The claims, the
+ * standards, the scopes, the review readings, the state vocabulary and the
+ * evidence names are all props, and the Block composes none of them into a
+ * sentence of its own. That is not a formality in this one place. A compliance
+ * surface is a set of representations made to regulators, to customers and to
+ * auditors, and a design system that contributed a word to one of them would be
+ * publishing a representation it has no standing to make. The cost of the rule is
+ * real and stated here: there is no default for anything, so a consumer wiring
+ * this Block up writes every label themselves, and a half-built compliance
+ * section is a build error rather than a page that ships six ticks.
+ *
+ * **The state is a tone and the words are the caller's, which is the same split
+ * `StatusLedger01` makes.** `Status` owns the five tones and refuses to pick one,
+ * and this Block maps its three states onto three of those tones while taking the
+ * words beside them from the caller. A publisher whose regimes say "attested"
+ * where another's say "held" is not a vocabulary this Block can reconcile, and a
+ * missing `stateLabel` throws rather than falling back to the machine value,
+ * which would print `in-progress` into a regulatory document as if it were a term
+ * of art.
+ *
+ * **`reviewedAt` is a string because a Block ships no formatting, and the honest
+ * reading of a review date is a Component rather than a call into `Intl`.** The
+ * alternative was to accept a `Date` and format it here, which is a Block
+ * choosing a locale, a calendar and a granularity on a publisher's regulatory
+ * behalf, and which would put `Intl` in every consumer's bundle for a rendering
+ * Prism has no stake in. So the value is printed exactly as passed. A caller who
+ * wants the reading to say "three months ago" composes `relative-time` beside
+ * this table, or formats the string themselves, and a Block that wanted the
+ * relative phrase would compose that Component rather than format inline. The
+ * cost is stated rather than hidden: a caller who passes an ISO string gets an
+ * ISO string, which is honest and rarely what was wanted.
+ *
+ * **The claim is the row header, so the table announces it with every cell.** The
+ * claim cell is a `th` with `scope="row"` rather than a `td`, which is what lets
+ * a screen reader say which claim each state and each date belongs to. The row
+ * header and the cells carry `whitespace-normal` and `h-auto` because
+ * `TableHead` and `TableCell` set `whitespace-nowrap` and a fixed header height,
+ * which is right for a figure in a data grid and wrong for a sentence that is a
+ * legal statement; that is the one place in this Block where a `className`
+ * changes a Prism-owned property rather than placing something, and it is stated
+ * here rather than left to be discovered.
+ *
+ * An empty set renders the table with no rows, which is deliberate and is the
+ * opposite of the rule every other Block in this package follows: a compliance
+ * section with a heading and no rows says "we publish nothing here", and hiding
+ * it would leave a reader wondering whether the section was missed. The cost is
+ * that a heading can survive on a page whose claims have all been withdrawn, so a
+ * consumer who would rather see nothing should not render the Block.
+ *
+ * It is a server Component: no hook, no state, no client code and no motion.
+ */
+export function Compliance01({ eyebrow, title, description, rows, columns, headingLevel = 'h2', className, }) {
+    // The handle a table below takes its name from; see the note on the table.
+    const headingId = useId();
+    return (_jsxs(Section, { className: className, children: [_jsx(SectionHeading, { as: headingLevel, id: headingId, align: "left", eyebrow: eyebrow, title: title, description: description, className: "mb-10" }), _jsxs(Table, { "aria-labelledby": headingId, "data-slot": "compliance", children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { scope: "col", children: columns.claim }), _jsx(TableHead, { scope: "col", children: columns.standard }), _jsx(TableHead, { scope: "col", children: columns.scope }), _jsx(TableHead, { scope: "col", children: columns.reviewedAt }), _jsx(TableHead, { scope: "col", children: columns.state }), _jsx(TableHead, { scope: "col", children: columns.evidence })] }) }), _jsx(TableBody, { children: rows.map((row) => {
+                            assertRow(row);
+                            return (_jsxs(TableRow, { "data-slot": "compliance-row", "data-compliance": row.id, children: [_jsx(TableHead, { scope: "row", className: "text-foreground h-auto whitespace-normal font-medium", children: row.claim }), _jsx(TableCell, { className: "whitespace-normal", children: row.standard === undefined ? null : row.standard }), _jsx(TableCell, { className: "whitespace-normal", children: row.scope ?? null }), _jsx(TableCell, { className: "tabular-nums", children: row.reviewedAt ?? null }), _jsx(TableCell, { children: row.state === undefined ? null : (_jsx(Status, { size: "sm", tone: STATE_TONE[row.state], label: row.stateLabel })) }), _jsx(TableCell, { children: row.evidenceHref === undefined ? null : (_jsx("a", { "data-slot": "compliance-evidence", href: row.evidenceHref, className: "text-foreground focus-visible:ring-ring rounded-sm underline underline-offset-4 transition-colors duration-fast ease-out focus-visible:ring-[3px] focus-visible:outline-none", children: row.evidenceLabel })) })] }, row.id));
+                        }) })] })] }));
+}
+export default Compliance01;

package/dist/blocks/compliance-01/index.d.ts

@@ -0,0 +1,3 @@
+export { Compliance01, default } from './compliance.js';
+export type { Compliance01Props, Compliance01Columns, Compliance01Row, ComplianceState, } from './compliance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blocks/compliance-01/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/compliance-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAKpD,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,eAAe,GAChB,MAAM,cAAc,CAAA"}

package/dist/blocks/compliance-01/index.js

@@ -0,0 +1 @@
+export { Compliance01, default } from './compliance.js';

package/dist/blocks/consent-01/consent.d.ts

@@ -0,0 +1,211 @@
+import type { ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * Where the notice sits, and which of the two costs the caller is choosing.
+ *
+ * **`banner` is the default and `dialog` exists for the case where a notice that
+ * covers the page's content is a notice the reader cannot avoid.** Both arms are
+ * real and the difference between them is not cosmetic, so neither is refused. What
+ * is refused is the idea that the choice belongs to the design system: which one is
+ * lawful depends on the caller's jurisdiction, what the caller's page is, and
+ * whether the caller's own layout can accommodate a surface that covers it, and
+ * none of those three is a fact this package holds.
+ *
+ * The default is `banner` because of the sentence above read the other way round. A
+ * notice over the content is a notice readers dismiss without reading, which is the
+ * behaviour a notice exists to prevent, and a consumer who has not thought about it
+ * should get the arrangement where a reader can scroll past and keep the page. A
+ * consumer whose counsel has told them otherwise passes `dialog` and owns the
+ * consequence, which is a reader who has been shown something and has not read it.
+ */
+export type Consent01Position = 'banner' | 'dialog';
+/** The props a Consent01 takes. Every string in this Block is one of them. */
+export type Consent01Props = {
+    /**
+     * The notice's heading, and required.
+     *
+     * A node rather than a string, because a notice's heading is often the product's
+     * own name plus a phrase and a caller composes that from two strings they already
+     * have, and because the same notice has to be readable at two different sizes
+     * depending on which arm drew it.
+     */
+    title: ReactNode;
+    /**
+     * What the reader is told, in the caller's own words.
+     *
+     * Required, and this is the one prop on the Block that Prism has no ability to
+     * help with at all. What a site tracks, with which processors, for how long, and
+     * what a reader's refusal changes are four facts about the caller's product and
+     * its agreements, and a Block that wrote them would be making representations
+     * about somebody else's data processing on a page the caller owns.
+     */
+    body: ReactNode;
+    /** The words on the control that records consent. */
+    acceptLabel: string;
+    /**
+     * The words on the control that records a refusal.
+     *
+     * Required rather than optional for the same reason `onReject` is, and drawn at
+     * the same size as the accept beside it. See the JSDoc on the Block for the
+     * argument, which is the whole reason this Item exists.
+     */
+    rejectLabel: string;
+    /**
+     * The words on the control that opens the caller's preferences surface.
+     *
+     * Required even though `onSettings` is not, and the reason is that the three
+     * names belong together in the caller's own vocabulary: a notice whose two
+     * visible controls are written next to each other and whose third name is
+     * deferred to wherever the preferences surface gets built is a notice whose
+     * three controls end up in two vocabularies. The honest cost is that a consumer
+     * with no preferences surface passes a name for a control this Block does not
+     * draw, and that is a placeholder in their own code rather than a change to this
+     * type.
+     */
+    settingsLabel: string;
+    /**
+     * Called when the reader accepts.
+     *
+     * **Required, and there is no arm of this component in which a reader is shown a
+     * notice they cannot refuse.** Both of these are required rather than one of
+     * them, because the shape that makes a notice unlawful is the one that offers a
+     * way forward and no way back, and an optional `onReject` is how that ships: a
+     * consumer who has not written a refusal path yet leaves the prop off, the Block
+     * draws the accept and nothing else, and the page is compliant with nobody.
+     */
+    onAccept: () => void;
+    /** Called when the reader refuses. Required for the reason `onAccept` is. */
+    onReject: () => void;
+    /**
+     * Called when the reader asks for their preferences.
+     *
+     * Optional, and a caller with nowhere to send them passes nothing: the control is
+     * not drawn at all rather than drawn as a dead end, and `settingsLabel` is the
+     * cost of that, stated above.
+     */
+    onSettings?: () => void;
+    /**
+     * Where the caller's policy is.
+     *
+     * Required, and it is required because a notice that says what it does and gives
+     * no way to read the detail is a claim with nothing behind it. The honest
+     * destination is the caller's own document rather than a route in this package,
+     * and Prism does not read it or check that it resolves.
+     */
+    policyHref: string;
+    /**
+     * The words on the link to the policy.
+     *
+     * The link's accessible name, so a required `string` for the same reason every
+     * accessible name in this package is one: a reader reaching towards a control has
+     * to hear what it is before they press it, and the name of a cookie policy is a
+     * sentence the caller writes.
+     */
+    policyLabel: string;
+    /**
+     * Whether the notice sits in the flow or covers the content.
+     *
+     * @defaultValue 'banner'
+     */
+    position?: Consent01Position;
+    /** Heading level for the notice's heading. See `HeadingLevel`. */
+    headingLevel?: HeadingLevel;
+    /**
+     * Layout only, on the `Section` this Block composes. Changing a Prism-owned
+     * visual property from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * A cookie and tracking notice with two peers, a route to the policy, and no memory.
+ *
+ * **Reject and accept are peers, and the reject is drawn at the same size and with
+ * the same reach as the accept. That is the whole reason this Block exists.** The
+ * obvious way to build this panel is a filled accept beside a `ghost` reject,
+ * because that is the arrangement every marketing site already has and because a
+ * filled button is what a button is for. It is also a dark pattern, and the reason
+ * a design system shipping it is worse than a product shipping it is that the
+ * design system shipped the styling: four consumers then inherit a reject that looks
+ * like a footnote, and none of them had to choose it. So the reject is drawn at
+ * `outline`, which is the same height, the same padding, the same coarse-pointer
+ * target and a border a reader can see, beside an accept that is filled. The two
+ * differ by fill and by nothing else, and the reader's eye is not asked to weigh
+ * them. The cost is named rather than hidden: a consumer who would rather the accept
+ * were the quiet one and the reject the loud one cannot restyle Prism's buttons,
+ * because the no-override-path rule is the reason this argument had to be made
+ * here, and the answer is to compose `Button` twice in their own panel.
+ *
+ * **The settings control is quieter than both, and that is a different claim.** The
+ * two peers are two decisions about the caller's tracking. The settings control is
+ * a route to a surface where a reader can change their mind later, and a reader who
+ * wants neither of the two decisions is exactly the reader who needs it, so drawing
+ * it at the same weight would spend a third control's emphasis on the least likely
+ * branch. It is `ghost` because it is a route rather than a decision. A reader who
+ * reached it and found nothing there is the cost, and the fix is not to pass
+ * `onSettings`.
+ *
+ * **The `dialog` arm exists, and the choice between the two is the caller's.** A
+ * notice that covers the page's content is a notice readers dismiss without reading,
+ * which is the behaviour a notice exists to prevent, and that is why `banner` is the
+ * default and why the in-flow panel is a full measure rather than something tucked
+ * into a corner. `dialog` is not refused, because a jurisdiction in some places
+ * requires the decision before the page is usable and a caller's own layout may have
+ * nowhere else to put a panel that must be unmissable. Which of the two is correct
+ * depends on the caller's jurisdiction, the caller's page and the caller's layout,
+ * and none of those is a fact this package holds, so the prop is required to be a
+ * decision rather than defaulted into an opinion. The cost of the covering arm is
+ * the sentence this Block opens with, and a caller who passes it has chosen it.
+ *
+ * **What the covering arm deliberately does not do, and the honest cost of that.**
+ * Prism does not put `role="dialog"` on it, does not make the page inert and does
+ * not trap focus, so a reader can Tab out of the panel into content behind a scrim
+ * that says the page is unavailable. That is a real hole and it is named here rather
+ * than hidden behind a role the markup cannot keep: `aria-modal` and a trapped
+ * focus ring are claims about behaviour, and a Block that set one without the other
+ * would be announcing a modal to assistive technology while the keyboard walked out
+ * of it. The answer for a caller who needs the behavioural half is `Dialog`, which
+ * does all three, and this Block's `banner` composed inside it. What `dialog` gives
+ * here is the visual half, which is the half a notice is usually missing.
+ *
+ * **Both handlers are required, so there is no arm in which a reader cannot
+ * refuse.** This is the same mechanism `HeroAction` uses for the same reason: the
+ * shape that forbids something says so in the type rather than in prose, and an
+ * optional `onReject` is a notice that can be shipped with no way out of it. A
+ * consumer who has not built a refusal path yet is exactly the consumer who would
+ * have left the prop off, which is why the refusal is the part that is required
+ * rather than the part that is convenient.
+ *
+ * **The Block persists nothing, and it does not remember the decision.** There is
+ * no cookie, no `localStorage`, no `document.cookie` and no state, so a page load
+ * shows the notice again until the caller stops rendering it. That is the correct
+ * default for a notice about something still true, and the alternative is a
+ * different thing and a deliberate act: a stored consent decision is a record in the
+ * consumer's own storage that outlives the notice, and it is the half of the feature
+ * a design system is least able to get right, because its correctness depends on the
+ * consumer's jurisdictions, on how long their records are kept, on whether a reader
+ * who clears their browsing data has to be asked again, and on whether a change to
+ * the policy invalidates the last decision. Prism has no standing to decide any of
+ * those, so the decision and its consequences are the consumer's. The cost is that
+ * a caller who wants the notice once writes the storage themselves, and a caller
+ * who writes nothing gets a notice that comes back, which is the safe direction to
+ * be wrong in. The handlers are the seam, and both are the caller's.
+ *
+ * **Prism pins nothing to the viewport, and that is a decision about the frame
+ * rather than about the notice.** A position in the reader's window is a position
+ * in their layout, and a Block that claimed one would be a Block every consumer had
+ * to move, which is the override path the rules exist to prevent. `position` chooses
+ * how the panel is presented inside the `Section` this Block composes: in the flow
+ * at the start of the container, or centred on a muted ground so the panel is the
+ * only thing in it. A consumer who wants the notice fixed to the bottom of the
+ * window puts this Block in a container they have fixed themselves.
+ *
+ * It is a client Component, and the reason is the handlers rather than the state,
+ * as in every other Block in this wave. `onAccept` is a function, a function is a
+ * piece of state, and state is a client module: a server component cannot hand an
+ * event handler down to a `<button>`, so a caller rendering this from a server
+ * component gets a notice whose two controls do nothing. There is no state in this
+ * file at all, so the client cost is the three handlers and not a running loop.
+ */
+export declare function Consent01({ title, body, acceptLabel, rejectLabel, settingsLabel, onAccept, onReject, onSettings, policyHref, policyLabel, position, headingLevel, className, }: Consent01Props): import("react").JSX.Element;
+export default Consent01;
+//# sourceMappingURL=consent.d.ts.map

package/dist/blocks/consent-01/consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.d.ts","sourceRoot":"","sources":["../../../src/blocks/consent-01/consent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAKtC,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAGxF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAEnD,8EAA8E;AAC9E,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;OAOG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB;;;;;;;;OAQG;IACH,IAAI,EAAE,SAAS,CAAA;IACf,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;;OAWG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;;;;;OASG;IACH,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAA;IACvB;;;;;;;OAOG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAA;IAC5B,kEAAkE;IAClE,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,IAAI,EACJ,WAAW,EACX,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,UAAU,EACV,WAAW,EACX,QAAmB,EACnB,YAAmB,EACnB,SAAS,GACV,EAAE,cAAc,+BA4FhB;AAED,eAAe,SAAS,CAAA"}

package/dist/blocks/consent-01/consent.js

@@ -0,0 +1,101 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../components/ui/button.js';
+import { Card, CardContent } from '../../components/ui/card.js';
+import { CtaLink } from '../../components/ui/cta-link.js';
+import { Section, SectionHeading } from '../../components/ui/section.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * A cookie and tracking notice with two peers, a route to the policy, and no memory.
+ *
+ * **Reject and accept are peers, and the reject is drawn at the same size and with
+ * the same reach as the accept. That is the whole reason this Block exists.** The
+ * obvious way to build this panel is a filled accept beside a `ghost` reject,
+ * because that is the arrangement every marketing site already has and because a
+ * filled button is what a button is for. It is also a dark pattern, and the reason
+ * a design system shipping it is worse than a product shipping it is that the
+ * design system shipped the styling: four consumers then inherit a reject that looks
+ * like a footnote, and none of them had to choose it. So the reject is drawn at
+ * `outline`, which is the same height, the same padding, the same coarse-pointer
+ * target and a border a reader can see, beside an accept that is filled. The two
+ * differ by fill and by nothing else, and the reader's eye is not asked to weigh
+ * them. The cost is named rather than hidden: a consumer who would rather the accept
+ * were the quiet one and the reject the loud one cannot restyle Prism's buttons,
+ * because the no-override-path rule is the reason this argument had to be made
+ * here, and the answer is to compose `Button` twice in their own panel.
+ *
+ * **The settings control is quieter than both, and that is a different claim.** The
+ * two peers are two decisions about the caller's tracking. The settings control is
+ * a route to a surface where a reader can change their mind later, and a reader who
+ * wants neither of the two decisions is exactly the reader who needs it, so drawing
+ * it at the same weight would spend a third control's emphasis on the least likely
+ * branch. It is `ghost` because it is a route rather than a decision. A reader who
+ * reached it and found nothing there is the cost, and the fix is not to pass
+ * `onSettings`.
+ *
+ * **The `dialog` arm exists, and the choice between the two is the caller's.** A
+ * notice that covers the page's content is a notice readers dismiss without reading,
+ * which is the behaviour a notice exists to prevent, and that is why `banner` is the
+ * default and why the in-flow panel is a full measure rather than something tucked
+ * into a corner. `dialog` is not refused, because a jurisdiction in some places
+ * requires the decision before the page is usable and a caller's own layout may have
+ * nowhere else to put a panel that must be unmissable. Which of the two is correct
+ * depends on the caller's jurisdiction, the caller's page and the caller's layout,
+ * and none of those is a fact this package holds, so the prop is required to be a
+ * decision rather than defaulted into an opinion. The cost of the covering arm is
+ * the sentence this Block opens with, and a caller who passes it has chosen it.
+ *
+ * **What the covering arm deliberately does not do, and the honest cost of that.**
+ * Prism does not put `role="dialog"` on it, does not make the page inert and does
+ * not trap focus, so a reader can Tab out of the panel into content behind a scrim
+ * that says the page is unavailable. That is a real hole and it is named here rather
+ * than hidden behind a role the markup cannot keep: `aria-modal` and a trapped
+ * focus ring are claims about behaviour, and a Block that set one without the other
+ * would be announcing a modal to assistive technology while the keyboard walked out
+ * of it. The answer for a caller who needs the behavioural half is `Dialog`, which
+ * does all three, and this Block's `banner` composed inside it. What `dialog` gives
+ * here is the visual half, which is the half a notice is usually missing.
+ *
+ * **Both handlers are required, so there is no arm in which a reader cannot
+ * refuse.** This is the same mechanism `HeroAction` uses for the same reason: the
+ * shape that forbids something says so in the type rather than in prose, and an
+ * optional `onReject` is a notice that can be shipped with no way out of it. A
+ * consumer who has not built a refusal path yet is exactly the consumer who would
+ * have left the prop off, which is why the refusal is the part that is required
+ * rather than the part that is convenient.
+ *
+ * **The Block persists nothing, and it does not remember the decision.** There is
+ * no cookie, no `localStorage`, no `document.cookie` and no state, so a page load
+ * shows the notice again until the caller stops rendering it. That is the correct
+ * default for a notice about something still true, and the alternative is a
+ * different thing and a deliberate act: a stored consent decision is a record in the
+ * consumer's own storage that outlives the notice, and it is the half of the feature
+ * a design system is least able to get right, because its correctness depends on the
+ * consumer's jurisdictions, on how long their records are kept, on whether a reader
+ * who clears their browsing data has to be asked again, and on whether a change to
+ * the policy invalidates the last decision. Prism has no standing to decide any of
+ * those, so the decision and its consequences are the consumer's. The cost is that
+ * a caller who wants the notice once writes the storage themselves, and a caller
+ * who writes nothing gets a notice that comes back, which is the safe direction to
+ * be wrong in. The handlers are the seam, and both are the caller's.
+ *
+ * **Prism pins nothing to the viewport, and that is a decision about the frame
+ * rather than about the notice.** A position in the reader's window is a position
+ * in their layout, and a Block that claimed one would be a Block every consumer had
+ * to move, which is the override path the rules exist to prevent. `position` chooses
+ * how the panel is presented inside the `Section` this Block composes: in the flow
+ * at the start of the container, or centred on a muted ground so the panel is the
+ * only thing in it. A consumer who wants the notice fixed to the bottom of the
+ * window puts this Block in a container they have fixed themselves.
+ *
+ * It is a client Component, and the reason is the handlers rather than the state,
+ * as in every other Block in this wave. `onAccept` is a function, a function is a
+ * piece of state, and state is a client module: a server component cannot hand an
+ * event handler down to a `<button>`, so a caller rendering this from a server
+ * component gets a notice whose two controls do nothing. There is no state in this
+ * file at all, so the client cost is the three handlers and not a running loop.
+ */
+export function Consent01({ title, body, acceptLabel, rejectLabel, settingsLabel, onAccept, onReject, onSettings, policyHref, policyLabel, position = 'banner', headingLevel = 'h2', className, }) {
+    return (_jsx(Section, { "data-slot": "consent-01", className: cn(className), children: _jsx("div", { "data-slot": "consent-01-stage", className: cn('flex w-full', position === 'dialog' ? 'justify-center rounded-2xl bg-muted/40 px-4 py-10' : null), children: _jsx(Card, { "data-slot": "consent-01-panel", className: "w-full max-w-measure gap-4", children: _jsxs(CardContent, { "data-slot": "consent-01-body", className: "flex flex-col gap-4", children: [_jsx(SectionHeading, { title: title, align: "left", as: headingLevel }), _jsx("div", { "data-slot": "consent-01-explanation", className: "text-muted-foreground text-pretty text-sm", children: body }), _jsxs("div", { "data-slot": "consent-01-controls", className: "flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center", children: [_jsx(Button, { "data-slot": "consent-01-accept", variant: "default", onClick: onAccept, children: acceptLabel }), _jsx(Button, { "data-slot": "consent-01-reject", variant: "outline", onClick: onReject, children: rejectLabel }), onSettings === undefined ? null : (_jsx(Button, { "data-slot": "consent-01-settings", variant: "ghost", size: "sm", onClick: onSettings, children: settingsLabel }))] }), _jsx(CtaLink, { "data-slot": "consent-01-policy", href: policyHref, variant: "ghost", size: "sm", className: "self-start", children: policyLabel })] }) }) }) }));
+}
+export default Consent01;

package/dist/blocks/consent-01/index.d.ts

@@ -0,0 +1,3 @@
+export { Consent01, default } from './consent.js';
+export type { Consent01Position, Consent01Props } from './consent.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blocks/consent-01/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/consent-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAI9C,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA"}

package/dist/blocks/consent-01/index.js

@@ -0,0 +1 @@
+export { Consent01, default } from './consent.js';