@nanisoft/prism-ui 0.13.0 → 0.16.0

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

@@ -0,0 +1,184 @@
+import { type ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/** One row of the comparison, when each point carries its own label. */
+export type Compare01Point = {
+    /**
+     * The row's name, as the caller writes it.
+     *
+     * A short noun phrase. The column is scanned top to bottom, and a label that
+     * wraps to two lines is a row whose two values sit at different heights.
+     */
+    label: string;
+    /** The value on this arm. The caller's node, rendered as the caller wrote it. */
+    value: ReactNode;
+};
+/**
+ * One row of the comparison, when the shared `labels` array names it.
+ *
+ * `label` is declared `never` rather than merely optional, so a caller who passes
+ * the shared array and also labels a point gets a type error instead of a matrix
+ * whose left column is named twice by two different words. See
+ * `Compare01Props.labels`.
+ */
+export type Compare01SharedPoint = {
+    /** Forbidden on this arm. The Block's `labels` array names this row. */
+    label?: never;
+    /** The value on this arm. */
+    value: ReactNode;
+};
+/**
+ * One arm of a comparison whose points carry their own labels.
+ *
+ * `name` is the arm's title: a `th scope="col"` in the `table` form and a heading
+ * at `childLevel(headingLevel)` in the `stacked` form, so it is the one thing in
+ * the Block a reader navigating by heading can land on.
+ */
+export type Compare01Arm = {
+    /** The arm's name, as the caller writes it. */
+    name: string;
+    /** One or two sentences about the arm, under its name. */
+    summary?: ReactNode;
+    /** A slot for whatever shows the arm: a figure, a screenshot, a code sample. */
+    media?: ReactNode;
+    /**
+     * The rows, in the order a reader should meet them, each carrying its own
+     * label. Order is the caller's because it is a claim about which difference
+     * matters first.
+     */
+    points: readonly Compare01Point[];
+};
+/**
+ * One arm of a comparison whose rows are named by the shared `labels` array.
+ *
+ * The same arm as `Compare01Arm` with the point's own label removed, which is the
+ * whole difference: the row names are one list because the two arms are the same
+ * shape, and a caller who has reached that conclusion should write it once.
+ */
+export type Compare01SharedArm = {
+    /** The arm's name, as the caller writes it. */
+    name: string;
+    /** One or two sentences about the arm, under its name. */
+    summary?: ReactNode;
+    /** A slot for whatever shows the arm. */
+    media?: ReactNode;
+    /** The rows, positionally paired with the Block's `labels`. */
+    points: readonly Compare01SharedPoint[];
+};
+/**
+ * The props a Compare01 takes.
+ *
+ * The last member is a union, and the union is the decision this Block made once.
+ * A comparison has a left column of row names, and there are exactly two ways to
+ * supply it: the names live on the points, or they live in one array that applies
+ * to both arms. Supporting both at once per arm is the shape this type refuses,
+ * because a comparison whose left arm names its rows and whose right arm does not
+ * is a table whose middle column is prose on one side and silence on the other,
+ * and the reader has to work out which side is the naming side. So the choice is
+ * made once, at the top, and the losing arm declares `label` as `never` so the
+ * compiler can see it. The cost is a props type a caller has to read before they
+ * write anything, and it is paid for a reason that shows up in the rendered page
+ * rather than in a type error.
+ *
+ * Every string is a prop and the Block ships none: no arm name, no summary, no row
+ * name and no value.
+ */
+export type Compare01Props = {
+    /** Optional label above the section title. See the No-Default-Eyebrow Rule. */
+    eyebrow?: ReactNode;
+    /** The section title. Omit it for a comparison composed under its own heading. */
+    title?: ReactNode;
+    /** One or two sentences under the title. */
+    description?: ReactNode;
+    /**
+     * Which form the comparison takes.
+     *
+     * `table` is a real table, and it scrolls sideways on a narrow screen, because a
+     * table that restacks has stopped being a table and a reader comparing by
+     * attribute is reading across a row. `stacked` puts one arm above the other and
+     * collapses to a single column, which costs the reader the side-by-side
+     * alignment they came for and buys them a page they can read on a phone. Both
+     * are legitimate and the difference is a fact about the reader's device rather
+     * than about the two things being compared, so the Block offers the two and does
+     * not pick. The rejected alternative was deciding from the viewport alone, which
+     * is a media query making a claim about how a reader compares.
+     *
+     * @defaultValue 'table'
+     */
+    variant?: 'table' | 'stacked';
+    /** Heading level for the section title. See `HeadingLevel`. */
+    headingLevel?: HeadingLevel;
+    /** Layout classes for the comparison. Layout only; every visual property is Prism's. */
+    className?: string;
+} & ({
+    /**
+     * Forbidden on this arm: the points carry their own labels, and a shared
+     * array beside them would be a second place for the same words.
+     */
+    labels?: never;
+    /** The left arm. */
+    left: Compare01Arm;
+    /** The right arm. */
+    right: Compare01Arm;
+} | {
+    /**
+     * The row names, one per row, in the order the rows appear. Required on
+     * this arm because it is what names the left column, and a comparison with
+     * no named rows is two columns of values with nothing to align them on.
+     */
+    labels: readonly string[];
+    /** The left arm. Its points carry no labels of their own. */
+    left: Compare01SharedArm;
+    /** The right arm. Its points carry no labels of their own. */
+    right: Compare01SharedArm;
+});
+/**
+ * Two things side by side, in the shape the word "compare" usually means: a
+ * two-column band with a shared row of labels down the left.
+ *
+ * **Prism ships no verdict, and the absence is the feature.** A compare Block is
+ * the one place on a marketing page where the surface is allowed to be unfair, and
+ * that is exactly why a design system has no standing in it. So there is no
+ * winner state, no check on the better column, no default highlight, no `featured`
+ * arm and no prop that would produce one. A design system that marks a winner is
+ * making a claim about a market it knows nothing about, in the same terms `Price`
+ * refuses to pick a currency: Prism is not entitled to a verdict either, and the
+ * two refusals are the same refusal. The cost is real and worth naming. A Block
+ * that could mark a winner would be a shorter thing to sell, it would demo better,
+ * and every consumer who used it would be publishing a comparison a competitor
+ * could read. So the Block lays out two arms, draws both at the same weight, and
+ * stops. The arms do not even take a `highlight`: symmetry is cheaper to defend
+ * than a documented exception.
+ *
+ * **A row whose two arms disagree is a row, and the Block says nothing about which
+ * is better.** There is no em, no tick, no colour and no ordering between the
+ * arms. A `value` is a node the caller composed, so a consumer that wants a check
+ * in one column puts a check in one column, in their own words and with their own
+ * judgement behind it, and Prism's part in that is not disagreeing. The cost of
+ * that refusal is that a caller cannot get a comparison to declare itself in one
+ * line, and the answer is that a comparison which declares itself is not a
+ * comparison any more.
+ *
+ * **The two narrow-screen answers are the caller's, and the Block decides once
+ * rather than per row.** `table` scrolls sideways on a narrow screen and `stacked`
+ * puts one arm above the other, for the reason `Compare01Props.variant` gives. The
+ * narrow-screen decision is made once, here, because a Block that re-decided it
+ * per row would be a table whose first two rows stack and whose rest do not.
+ *
+ * **The label column is a real column and the choice of who names it is made once.**
+ * See `Compare01Props` for the union. A shared array is the better fit when the two
+ * arms are the same shape, which is the usual case, and per-point labels are the
+ * better fit when one arm has a row the other has no answer for. What is not
+ * available is the half-and-half case, because a left column named by two
+ * mechanisms is a column no reader can rely on.
+ *
+ * **Arms of different lengths are refused rather than padded.** A column with a
+ * missing cell is a claim about a product, made by a comparison whose own data
+ * disagreed with it, and no amount of quiet padding makes that the caller's
+ * intent. The check runs before anything is rendered, and it names both counts in
+ * the message so the fix is a one-line edit at the call site.
+ *
+ * It is a server Component: no hook, no state, no client code and no router.
+ */
+export declare function Compare01(props: Compare01Props): import("react").JSX.Element;
+export default Compare01;
+//# sourceMappingURL=compare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/blocks/compare-01/compare.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAG7C,OAAO,EAAuC,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAWpG,wEAAwE;AACxE,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,iFAAiF;IACjF,KAAK,EAAE,SAAS,CAAA;CACjB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,wEAAwE;IACxE,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,6BAA6B;IAC7B,KAAK,EAAE,SAAS,CAAA;CACjB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,0DAA0D;IAC1D,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB;;;;OAIG;IACH,MAAM,EAAE,SAAS,cAAc,EAAE,CAAA;CAClC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,0DAA0D;IAC1D,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,yCAAyC;IACzC,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,+DAA+D;IAC/D,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAA;CACxC,CAAA;AAQD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,kFAAkF;IAClF,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,wFAAwF;IACxF,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,CACA;IACE;;;OAGG;IACH,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,oBAAoB;IACpB,IAAI,EAAE,YAAY,CAAA;IAClB,qBAAqB;IACrB,KAAK,EAAE,YAAY,CAAA;CACpB,GACD;IACE;;;;OAIG;IACH,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IACzB,6DAA6D;IAC7D,IAAI,EAAE,kBAAkB,CAAA;IACxB,8DAA8D;IAC9D,KAAK,EAAE,kBAAkB,CAAA;CAC1B,CACJ,CAAA;AAoFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,+BAsI9C;AAED,eAAe,SAAS,CAAA"}

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

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '../../components/ui/card.js';
+import { Section, SectionHeading, childLevel } from '../../components/ui/section.js';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from '../../components/ui/table.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * The row names, read from whichever shape arrived.
+ *
+ * The two branches are the union's two arms, and only one of them is reachable for
+ * a given `shared`: with the shared array present every element is a
+ * `Compare01SharedPoint` and the array is the total source of names, and with it
+ * absent every element is a `Compare01Point` whose `label` is required. The
+ * `?? ''` is the price of holding both element types in one array, and it is
+ * unreachable for a caller who wrote TypeScript.
+ */
+function rowNames(points, shared) {
+    if (shared !== undefined)
+        return shared;
+    return points.map((point) => point.label ?? '');
+}
+/** One row of the `table` form: the row's name, then a value per arm. */
+function CompareRow({ label, left, right, }) {
+    return (_jsxs(TableRow, { children: [_jsx(TableHead, { scope: "row", className: "w-56 align-top whitespace-normal font-normal", children: _jsx("span", { className: "text-sm font-medium", children: label }) }), _jsx(TableCell, { className: "align-top whitespace-normal", children: left }), _jsx(TableCell, { className: "align-top whitespace-normal", children: right })] }));
+}
+/** One arm of the `stacked` form: a titled card, its media, and its own rows. */
+function StackedArm({ name, summary, media, points, rows, Heading, }) {
+    return (_jsxs(Card, { "data-slot": "compare-arm", className: "gap-4", children: [_jsxs(CardHeader, { children: [_jsx(CardTitle, { as: Heading, children: name }), summary ? _jsx(CardDescription, { children: summary }) : null] }), media ? _jsx("div", { "data-slot": "compare-media", children: media }) : null, _jsx(CardContent, { children: _jsx("dl", { className: "flex flex-col gap-3", children: points.map((point, index) => (_jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("dt", { className: "text-muted-foreground text-xs font-medium", children: rows[index] }), _jsx("dd", { className: "text-pretty text-sm", children: point.value })] }, index))) }) })] }));
+}
+/**
+ * Two things side by side, in the shape the word "compare" usually means: a
+ * two-column band with a shared row of labels down the left.
+ *
+ * **Prism ships no verdict, and the absence is the feature.** A compare Block is
+ * the one place on a marketing page where the surface is allowed to be unfair, and
+ * that is exactly why a design system has no standing in it. So there is no
+ * winner state, no check on the better column, no default highlight, no `featured`
+ * arm and no prop that would produce one. A design system that marks a winner is
+ * making a claim about a market it knows nothing about, in the same terms `Price`
+ * refuses to pick a currency: Prism is not entitled to a verdict either, and the
+ * two refusals are the same refusal. The cost is real and worth naming. A Block
+ * that could mark a winner would be a shorter thing to sell, it would demo better,
+ * and every consumer who used it would be publishing a comparison a competitor
+ * could read. So the Block lays out two arms, draws both at the same weight, and
+ * stops. The arms do not even take a `highlight`: symmetry is cheaper to defend
+ * than a documented exception.
+ *
+ * **A row whose two arms disagree is a row, and the Block says nothing about which
+ * is better.** There is no em, no tick, no colour and no ordering between the
+ * arms. A `value` is a node the caller composed, so a consumer that wants a check
+ * in one column puts a check in one column, in their own words and with their own
+ * judgement behind it, and Prism's part in that is not disagreeing. The cost of
+ * that refusal is that a caller cannot get a comparison to declare itself in one
+ * line, and the answer is that a comparison which declares itself is not a
+ * comparison any more.
+ *
+ * **The two narrow-screen answers are the caller's, and the Block decides once
+ * rather than per row.** `table` scrolls sideways on a narrow screen and `stacked`
+ * puts one arm above the other, for the reason `Compare01Props.variant` gives. The
+ * narrow-screen decision is made once, here, because a Block that re-decided it
+ * per row would be a table whose first two rows stack and whose rest do not.
+ *
+ * **The label column is a real column and the choice of who names it is made once.**
+ * See `Compare01Props` for the union. A shared array is the better fit when the two
+ * arms are the same shape, which is the usual case, and per-point labels are the
+ * better fit when one arm has a row the other has no answer for. What is not
+ * available is the half-and-half case, because a left column named by two
+ * mechanisms is a column no reader can rely on.
+ *
+ * **Arms of different lengths are refused rather than padded.** A column with a
+ * missing cell is a claim about a product, made by a comparison whose own data
+ * disagreed with it, and no amount of quiet padding makes that the caller's
+ * intent. The check runs before anything is rendered, and it names both counts in
+ * the message so the fix is a one-line edit at the call site.
+ *
+ * It is a server Component: no hook, no state, no client code and no router.
+ */
+export function Compare01(props) {
+    // The handle a table below takes its name from; see the note on the table.
+    const headingId = useId();
+    const { eyebrow, title, description, variant = 'table', headingLevel = 'h2', className } = props;
+    const shared = props.labels;
+    const { left, right } = props;
+    const leftPoints = left.points;
+    const rightPoints = right.points;
+    if (leftPoints.length !== rightPoints.length) {
+        throw new Error(`Compare01: the arm '${left.name}' has ${leftPoints.length} point(s) and the arm ` +
+            `'${right.name}' has ${rightPoints.length}. A comparison whose arms are different lengths is a ` +
+            'column with a missing cell, so the lengths are checked rather than padded.');
+    }
+    if (shared !== undefined && shared.length !== leftPoints.length) {
+        throw new Error(`Compare01: the arm '${left.name}' has ${leftPoints.length} point(s) and labels has ` +
+            `${shared.length} name(s). A comparison whose rows are not named one for one is a row with no ` +
+            'name or a name with no row, so the lengths are checked rather than padded.');
+    }
+    const rows = rowNames(leftPoints, shared);
+    // The arm names are the two column headings, so they are titles inside the
+    // section that introduces the comparison.
+    const ArmHeading = childLevel(headingLevel);
+    return (_jsxs(Section, { children: [title ? (_jsx(SectionHeading, { as: headingLevel, id: headingId, align: "left", eyebrow: eyebrow, title: title, description: description, className: "mb-12" })) : null, variant === 'stacked' ? (_jsxs("div", { "data-slot": "compare", "data-variant": "stacked", className: cn('grid gap-6 lg:grid-cols-2', className), children: [_jsx(StackedArm, { name: left.name, summary: left.summary, media: left.media, points: leftPoints, rows: rows, Heading: ArmHeading }), _jsx(StackedArm, { name: right.name, summary: right.summary, media: right.media, points: rightPoints, rows: rows, Heading: ArmHeading })] })) : (_jsx("div", { "data-slot": "compare", "data-variant": "table", className: cn('flex flex-col gap-4', className), children: _jsx("div", { className: "border-border overflow-hidden rounded-xl border", children: _jsxs(Table, { "aria-labelledby": title ? headingId : undefined, children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { className: "w-56" }), [left, right].map((arm, index) => (_jsx(TableHead, { scope: "col", className: "whitespace-normal align-bottom", children: _jsxs("div", { className: "flex flex-col items-start gap-1", children: [_jsx(ArmHeading, { className: "text-base font-semibold tracking-tight text-balance", children: arm.name }), arm.summary ? (_jsx("span", { className: "text-muted-foreground text-sm font-normal", children: arm.summary })) : null, arm.media ? _jsx("div", { "data-slot": "compare-media", children: arm.media }) : null] }) }, index)))] }) }), _jsx(TableBody, { children: rows.map((row, index) => (
+                                // Positional: a row name is display content and a caller may
+                                // legitimately compare the same attribute twice under two
+                                // headings, which keying on the name would punish.
+                                _jsx(CompareRow, { label: row, left: leftPoints[index].value, right: rightPoints[index].value }, index))) })] }) }) }))] }));
+}
+export default Compare01;

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

@@ -0,0 +1,3 @@
+export { Compare01, default } from './compare.js';
+export type { Compare01Arm, Compare01Point, Compare01Props, Compare01SharedArm, Compare01SharedPoint, } from './compare.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/compare-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAK9C,YAAY,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,WAAW,CAAA"}

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

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

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

@@ -0,0 +1,249 @@
+import { type ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * The three states a compliance row can be in.
+ *
+ * Three, and the set is closed. It is `Status`'s set of five tones narrowed to
+ * the states a claim about a standard can actually be in, and the narrowing is
+ * the argument: a compliance surface has no `destructive` row, because "we do not
+ * hold this" is not a claim a publisher makes about a standard it has chosen to
+ * publish, and a surface with a destructive state on it invites exactly the
+ * marketing use this Block exists to refuse.
+ */
+export type ComplianceState = 'held' | 'in-progress' | 'not-applicable';
+/**
+ * One claim, and everything that makes it checkable.
+ *
+ * The words in every one of these fields are the caller's legal statements, not
+ * Prism's. See the Block's JSDoc for why that sentence is load-bearing rather
+ * than a formality.
+ */
+type Compliance01RowBase = {
+    /**
+     * A stable key for the row, and carried on the markup as `data-compliance` so
+     * a test can name one claim rather than the first one.
+     */
+    id: string;
+    /**
+     * What is claimed, in the publisher's own words.
+     *
+     * The anchor of the row and the row header the table announces with it. It is
+     * the sentence a reader checks against the document beside it, so it is not
+     * shortened, softened or rewritten here.
+     */
+    claim: string;
+    /**
+     * The standard, framework or control the claim is made against.
+     *
+     * Optional, and its absence is meaningful rather than a gap: a claim with no
+     * standard is a statement the publisher has made about itself, and there is no
+     * tick to draw for it. See the Block's JSDoc for the refusal.
+     */
+    standard?: string;
+    /**
+     * What the claim covers: which system, which region, which version.
+     *
+     * A compliance claim without a scope is a claim about everything, which is a
+     * stronger claim than any publisher can usually support, and this Block does
+     * not write the scope for them.
+     */
+    scope?: string;
+    /**
+     * When the claim was last reviewed, already written as it should be read.
+     *
+     * A string rather than a `Date`, and that is a decision with a reason: this is
+     * a Block and a Block ships no formatting, so the reading is the caller's
+     * string rather than a date Prism would have to turn into words. The honest
+     * reading of a review date is a `relative-time`, which is a Component a caller
+     * composes; see the Block's JSDoc.
+     */
+    reviewedAt?: string;
+    /**
+     * The state of the claim, drawn from the tone set `Status` owns.
+     *
+     * Optional, and a row with no state says nothing about its own status, which
+     * is the honest reading of a claim nobody has labelled. A `held` claim also
+     * needs a `standard`; see the Block's JSDoc.
+     */
+    state?: ComplianceState;
+    /**
+     * The words for the state, in the publisher's own vocabulary.
+     *
+     * Required whenever `state` is given, and not defaulted, for the reason
+     * `StatusLedger01`'s `statusLabel` states in full: the state is a colour and
+     * the words are the information, and a publisher whose regimes say "attested"
+     * where another's say "held" cannot be given one vocabulary by a design system.
+     * A missing one is a thrown diagnostic rather than a silent absence.
+     */
+    stateLabel?: string;
+};
+/**
+ * One row of the claims table.
+ *
+ * **The evidence pair is a union, and that is the whole of why this is a type
+ * alias over an interface.** The four fields a row always carries are on every
+ * arm, and the two fields that describe an evidence link are on one arm together:
+ * a row either links to a published document and names it, or it does neither.
+ * Declaring `evidenceHref` and `evidenceLabel` as two independent optional
+ * properties would have produced three states a compliance table must never show,
+ * a link with no name, a name with no link, and neither, and only the first of
+ * those is what the optional pair was trying to say.
+ *
+ * The `state` pair works the same way and for the same reason, and the
+ * `stateLabel` is a separate union below for the same reason again: a state is a
+ * colour and the words beside it are the information.
+ */
+export type Compliance01Row = Compliance01RowBase & ({
+    /**
+     * Where the evidence is: a native anchor `href`.
+     *
+     * Omit it and the cell says nothing, which is a truthful answer. A claim
+     * with no published document behind it has no evidence link, and this
+     * Block will not link to a contact form to fill the gap.
+     */
+    evidenceHref: string;
+    /**
+     * The words that name the evidence, and the link's accessible name.
+     *
+     * Required on this arm and forbidden on the other one, so a link whose
+     * accessible name is its address is a compile error rather than
+     * something a screen reader announces as punctuation, and a name with no
+     * link beside it is a compile error rather than a sentence in an empty
+     * cell. The words are the caller's, because the words say which document
+     * this is.
+     */
+    evidenceLabel: string;
+} | {
+    /** Forbidden, so that "a link with no name" cannot be typed. */
+    evidenceHref?: never;
+    /** Forbidden, so that "a name with no link" cannot be typed either. */
+    evidenceLabel?: never;
+});
+/**
+ * What each column says it holds.
+ *
+ * Six nodes and all six required, because a compliance table whose columns are
+ * unnamed is a grid, and a grid of claims is a set of assertions with nothing to
+ * check them against. The words are the caller's because what a publisher calls
+ * its review date, its scope and its evidence is part of the claim rather than
+ * part of the layout.
+ */
+export type Compliance01Columns = {
+    /** Above the claim column, which is also the row header the table announces. */
+    claim: ReactNode;
+    /** Above the standard column. */
+    standard: ReactNode;
+    /** Above the scope column. */
+    scope: ReactNode;
+    /** Above the last reviewed column. */
+    reviewedAt: ReactNode;
+    /** Above the state column. */
+    state: ReactNode;
+    /** Above the evidence column. */
+    evidence: ReactNode;
+};
+/**
+ * The props a Compliance01 takes.
+ *
+ * Every string is a prop and the Block ships none. There is no standard list, no
+ * certification vocabulary, no default state and not one word of a claim: a
+ * compliance surface that shipped any of them would be making statements about a
+ * publisher's regulatory position on their behalf.
+ */
+export type Compliance01Props = {
+    /** Optional label above the section title. See the No-Default-Eyebrow Rule. */
+    eyebrow?: string;
+    /**
+     * The section title, required.
+     *
+     * Required because this is the one surface in the system where an unlabelled
+     * table of claims is a defect rather than a layout: a table of assertions with
+     * no statement of who is making them reads as a certification nobody issued.
+     */
+    title: ReactNode;
+    /** One or two sentences under the title. */
+    description?: ReactNode;
+    /** The claims, in the order a reader should meet them. Order is the caller's. */
+    rows: readonly Compliance01Row[];
+    /** What each column says it holds. See `Compliance01Columns`. */
+    columns: Compliance01Columns;
+    /** Heading level for the section title. See `HeadingLevel`. */
+    headingLevel?: HeadingLevel;
+    /**
+     * Layout only, exactly as on every Component. Changing a Prism-owned visual
+     * property from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * 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 declare function Compliance01({ eyebrow, title, description, rows, columns, headingLevel, className, }: Compliance01Props): import("react").JSX.Element;
+export default Compliance01;
+//# sourceMappingURL=compliance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compliance.d.ts","sourceRoot":"","sources":["../../../src/blocks/compliance-01/compliance.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAE7C,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAWxF;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,aAAa,GAAG,gBAAgB,CAAA;AAmBvE;;;;;;GAMG;AACH,KAAK,mBAAmB,GAAG;IACzB;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAA;IACV;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAC/C,CACI;IACE;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;;;;;;;;OASG;IACH,aAAa,EAAE,MAAM,CAAA;CACtB,GACD;IACE,gEAAgE;IAChE,YAAY,CAAC,EAAE,KAAK,CAAA;IACpB,uEAAuE;IACvE,aAAa,CAAC,EAAE,KAAK,CAAA;CACtB,CACJ,CAAA;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,gFAAgF;IAChF,KAAK,EAAE,SAAS,CAAA;IAChB,iCAAiC;IACjC,QAAQ,EAAE,SAAS,CAAA;IACnB,8BAA8B;IAC9B,KAAK,EAAE,SAAS,CAAA;IAChB,sCAAsC;IACtC,UAAU,EAAE,SAAS,CAAA;IACrB,8BAA8B;IAC9B,KAAK,EAAE,SAAS,CAAA;IAChB,iCAAiC;IACjC,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;OAMG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB,iFAAiF;IACjF,IAAI,EAAE,SAAS,eAAe,EAAE,CAAA;IAChC,iEAAiE;IACjE,OAAO,EAAE,mBAAmB,CAAA;IAC5B,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AA0CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,KAAK,EACL,WAAW,EACX,IAAI,EACJ,OAAO,EACP,YAAmB,EACnB,SAAS,GACV,EAAE,iBAAiB,+BAmFnB;AAED,eAAe,YAAY,CAAA"}