@nanisoft/prism-ui 0.13.0 → 0.15.0

package/dist/blocks/case-study-01/case-study.d.ts

@@ -0,0 +1,214 @@
+import { type ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * One figure the customer is asserting.
+ *
+ * Every field is the customer's own: the number, the label that says what it
+ * measures, and the delta and the hint. See the Block's JSDoc for why this row
+ * is the reason the Block exists.
+ */
+export type CaseStudy01Result = {
+    /** What the figure measures, in the customer's words. */
+    label: string;
+    /**
+     * The figure, already formatted.
+     *
+     * A node rather than a number, for the reason `Metric` takes a node: a figure a
+     * consumer formatted itself is a machine reading, and this package attaches no
+     * unit to a number it has never seen.
+     */
+    value: ReactNode;
+    /**
+     * The change against the previous period, as a plain number.
+     *
+     * No unit, because Prism cannot know whether this is twelve percent or twelve
+     * seconds, and `Metric` prints the number exactly as passed unless the caller
+     * gives it a formatter. Pass `0.12` and the row reads `0.12`.
+     */
+    delta?: number;
+    /** The period, the source or the caveat that matters here. */
+    hint?: ReactNode;
+};
+/**
+ * A quotation, with the person who said it.
+ *
+ * The words are the customer's and so are the person's: a case study that puts
+ * words in a named person's mouth is a fabrication with an attribution on it.
+ */
+export type CaseStudy01Quote = {
+    /** What the person said. */
+    quote: ReactNode;
+    /** Who said it, as they are named. */
+    name: string;
+    /** What they do, where the customer publishes it. */
+    role?: string;
+};
+/** Everything a CaseStudy01 takes, other than whether a quote was given. */
+type CaseStudy01CommonProps = {
+    /** Optional label above the section title. See the No-Default-Eyebrow Rule. */
+    eyebrow?: string;
+    /**
+     * The section title, when it is not the customer name.
+     *
+     * Omit it and the customer's name is the section heading, which is the right
+     * default here: a case study headed by the work rather than by the customer
+     * invites the reader to read it as a claim about a customer rather than about
+     * a result. The customer's name is drawn in the body either way, so passing a
+     * title never hides it.
+     */
+    title?: ReactNode;
+    /**
+     * Whose it is.
+     *
+     * Required, and required because a case study without a named customer is an
+     * advertisement with a paragraph attached. The name is a claim about another
+     * organisation, so it is the consumer's to publish and Prism's only to draw.
+     */
+    customer: string;
+    /** The sector the customer is in, as a label. */
+    sector?: string;
+    /**
+     * The one-paragraph account of what happened.
+     *
+     * Required, because a case study with no account is a logo with a number under
+     * it. It is the paragraph a reader reads before deciding whether the figures
+     * below it mean anything.
+     */
+    summary: ReactNode;
+    /**
+     * The problem, as authored content.
+     *
+     * A node rather than a string because this is a run of prose and the caller
+     * authors prose: paragraphs, lists, a heading. A Block that took a string would
+     * be taking one paragraph where the caller wrote three. If the run contains a
+     * heading, compose it at `childLevel(headingLevel)`, which is a fact about where
+     * the Block was placed and so is the caller's to get right.
+     */
+    problem?: ReactNode;
+    /**
+     * What was done, as authored content.
+     *
+     * Same shape as `problem` and the same rule about a heading inside it.
+     */
+    approach?: ReactNode;
+    /**
+     * The figures the customer is asserting.
+     *
+     * Required, and an empty array renders no results strip at all rather than two
+     * hairlines around nothing. A case study with no result is a case study with no
+     * case, and the type says the row is owed while the renderer declines to draw
+     * an empty frame. Every figure here is the customer's assertion and none of
+     * them is Prism's.
+     */
+    results: readonly CaseStudy01Result[];
+    /** The caller's actions, for the sentence that asks the reader what to do. */
+    actions?: ReactNode;
+    /**
+     * `stacked` puts the narrative above the figures. `split` puts the narrative in
+     * the left column and the figures and the quotation in the right one.
+     *
+     * @defaultValue 'stacked'
+     */
+    layout?: 'stacked' | 'split';
+    /** 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;
+};
+/**
+ * The props a CaseStudy01 takes.
+ *
+ * The union is the one place in this Block where the type system earns its keep:
+ * `quoteLabel` is required in exactly the shape where a quotation is rendered and
+ * meaningless in the shape where none is, and two independent optionals could not
+ * say that. This is the `HeroAction` rule applied to a figure rather than to an
+ * anchor.
+ */
+export type CaseStudy01Props = CaseStudy01CommonProps & ({
+    /** The quotation to close with. */
+    quote: CaseStudy01Quote;
+    /**
+     * The figure's accessible name, so a reader is told this is a quotation
+     * rather than body copy.
+     *
+     * Required whenever `quote` is given. A blockquote with no name is a run
+     * of italic text that a screen reader reads as the page own words, and a
+     * case study whose quotation is indistinguishable from its own prose is a
+     * misattribution waiting to happen.
+     */
+    quoteLabel: string;
+} | {
+    /** No quotation, and therefore no name owed for one. */
+    quote?: never;
+    quoteLabel?: never;
+});
+/**
+ * One case study in full: a customer, a sector, the problem, what was done, the
+ * figures the customer asserts, and optionally a quotation.
+ *
+ * **The results row is the reason this Block exists, and every figure in it is
+ * the caller's.** A case study is the one page on a marketing site where a
+ * number is legally dangerous. Every other number on a marketing page is
+ * decoration the reader can discount, and a number under the word "results" is a
+ * statement of fact about a third party that a publisher is accountable for. So
+ * `results` is a prop, every field of it is a prop, `Metric` is handed the value
+ * the consumer formatted and is never asked what unit it is in, and there is not
+ * one figure, one percentage and one period in this package. The alternative was
+ * a Block that shipped a plausible reduction figure, which is worse than useless:
+ * it is a false advertising claim that installs itself into every consumer's
+ * product, on a page nobody in this repository has any standing to publish, and
+ * the consumer who left it alone would inherit it silently. That is the whole
+ * design, and every other decision below is smaller than it.
+ *
+ * **`delta` is a bare number and the row says exactly what it was given.** `0.12`
+ * prints as `0.12`, because `Metric` takes an optional formatter and Prism has no
+ * formatter for a caller's domain. The honest arrangement is to put the unit in
+ * `value`, where the consumer formatted it, or to pass a formatter; the cost of
+ * the refusal is a row that says `0.12` where the reader hoped for `12%`, which is
+ * honest and usually not what was wanted. Stating that is better than guessing
+ * a percent sign onto a number about somebody else's revenue.
+ *
+ * **`quoteLabel` is required with a quotation, and it names the `figure`.** The
+ * quotation is a `figure` rather than a `blockquote` on its own so that it has a
+ * name, and the name is drawn as a visually hidden node inside that figure and
+ * reached with `aria-labelledby` from a generated id. Without it a screen reader
+ * reads the quotation as the page's own sentences, and a case study in which the
+ * quotation cannot be told from the prose is a case study that misattributes
+ * words. `useId` is the source of that id for the reason `ListPanel` states: a
+ * hand-counted id collides the moment two case studies are on one page, which is
+ * exactly what happens on a marketing site.
+ *
+ * **The narrative is `Prose`, so the caller writes prose and Prism holds the
+ * measure.** `problem` and `approach` are nodes rather than strings because they
+ * are runs of authored content: paragraphs, lists, a heading. A Block that took a
+ * string would take one paragraph where the consumer wrote three, which is how a
+ * case study ends up with a wall of semicolon-separated claims. The cost is
+ * stated rather than hidden: the run arrives unstyled, so a caller who wants a
+ * label above it composes its own heading, and that heading should be at
+ * `childLevel(headingLevel)` because the level of a heading inside authored prose
+ * is a fact about where the Block was placed.
+ *
+ * **`stacked` and `split` are two arrangements of the same content and neither
+ * changes what is claimed.** A stacked study reads the account first and the
+ * figures after it, which suits a long narrative; a split one puts the figures
+ * beside the account, which suits a reader who came for the number. The Block
+ * does not choose between them and does not decide how many figures fit either
+ * way, so a caller with five figures gets five figures in both.
+ *
+ * The section title is `title` when given and the customer's name otherwise, and
+ * the customer's name is drawn in the body either way. The section is the one
+ * place in this package where the heading is a claim about a third party, which
+ * is why the name is a required prop and never a default: there is no anonymous
+ * case study here, and a generic label standing in for a name would be an
+ * advertisement rather than a study.
+ *
+ * It is a server Component: no hook, no state and no client code. `useId` is the
+ * one React call it makes, and it is the call the server render supports, which
+ * `ListPanel`, `FilterPanel` and `FileUpload` already depend on.
+ */
+export declare function CaseStudy01({ eyebrow, title, customer, sector, summary, problem, approach, results, quote, quoteLabel, actions, layout, headingLevel, className, }: CaseStudy01Props): import("react").JSX.Element;
+export default CaseStudy01;
+//# sourceMappingURL=case-study.d.ts.map

package/dist/blocks/case-study-01/case-study.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-study.d.ts","sourceRoot":"","sources":["../../../src/blocks/case-study-01/case-study.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAK7C,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAGxF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4BAA4B;IAC5B,KAAK,EAAE,SAAS,CAAA;IAChB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,4EAA4E;AAC5E,KAAK,sBAAsB,GAAG;IAC5B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,OAAO,EAAE,SAAS,CAAA;IAClB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB;;;;;;;;OAQG;IACH,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAA;IACrC,8EAA8E;IAC9E,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAA;IAC5B,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GACnD,CACI;IACE,mCAAmC;IACnC,KAAK,EAAE,gBAAgB,CAAA;IACvB;;;;;;;;OAQG;IACH,UAAU,EAAE,MAAM,CAAA;CACnB,GACD;IACE,wDAAwD;IACxD,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,UAAU,CAAC,EAAE,KAAK,CAAA;CACnB,CACJ,CAAA;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,KAAK,EACL,QAAQ,EACR,MAAM,EACN,OAAO,EACP,OAAO,EACP,QAAQ,EACR,OAAO,EACP,KAAK,EACL,UAAU,EACV,OAAO,EACP,MAAkB,EAClB,YAAmB,EACnB,SAAS,GACV,EAAE,gBAAgB,+BAwGlB;AAED,eAAe,WAAW,CAAA"}

package/dist/blocks/case-study-01/case-study.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { Badge } from '../../components/ui/badge.js';
+import { Metric } from '../../components/ui/metric.js';
+import { Prose } from '../../components/ui/prose.js';
+import { Section, SectionHeading } from '../../components/ui/section.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * One case study in full: a customer, a sector, the problem, what was done, the
+ * figures the customer asserts, and optionally a quotation.
+ *
+ * **The results row is the reason this Block exists, and every figure in it is
+ * the caller's.** A case study is the one page on a marketing site where a
+ * number is legally dangerous. Every other number on a marketing page is
+ * decoration the reader can discount, and a number under the word "results" is a
+ * statement of fact about a third party that a publisher is accountable for. So
+ * `results` is a prop, every field of it is a prop, `Metric` is handed the value
+ * the consumer formatted and is never asked what unit it is in, and there is not
+ * one figure, one percentage and one period in this package. The alternative was
+ * a Block that shipped a plausible reduction figure, which is worse than useless:
+ * it is a false advertising claim that installs itself into every consumer's
+ * product, on a page nobody in this repository has any standing to publish, and
+ * the consumer who left it alone would inherit it silently. That is the whole
+ * design, and every other decision below is smaller than it.
+ *
+ * **`delta` is a bare number and the row says exactly what it was given.** `0.12`
+ * prints as `0.12`, because `Metric` takes an optional formatter and Prism has no
+ * formatter for a caller's domain. The honest arrangement is to put the unit in
+ * `value`, where the consumer formatted it, or to pass a formatter; the cost of
+ * the refusal is a row that says `0.12` where the reader hoped for `12%`, which is
+ * honest and usually not what was wanted. Stating that is better than guessing
+ * a percent sign onto a number about somebody else's revenue.
+ *
+ * **`quoteLabel` is required with a quotation, and it names the `figure`.** The
+ * quotation is a `figure` rather than a `blockquote` on its own so that it has a
+ * name, and the name is drawn as a visually hidden node inside that figure and
+ * reached with `aria-labelledby` from a generated id. Without it a screen reader
+ * reads the quotation as the page's own sentences, and a case study in which the
+ * quotation cannot be told from the prose is a case study that misattributes
+ * words. `useId` is the source of that id for the reason `ListPanel` states: a
+ * hand-counted id collides the moment two case studies are on one page, which is
+ * exactly what happens on a marketing site.
+ *
+ * **The narrative is `Prose`, so the caller writes prose and Prism holds the
+ * measure.** `problem` and `approach` are nodes rather than strings because they
+ * are runs of authored content: paragraphs, lists, a heading. A Block that took a
+ * string would take one paragraph where the consumer wrote three, which is how a
+ * case study ends up with a wall of semicolon-separated claims. The cost is
+ * stated rather than hidden: the run arrives unstyled, so a caller who wants a
+ * label above it composes its own heading, and that heading should be at
+ * `childLevel(headingLevel)` because the level of a heading inside authored prose
+ * is a fact about where the Block was placed.
+ *
+ * **`stacked` and `split` are two arrangements of the same content and neither
+ * changes what is claimed.** A stacked study reads the account first and the
+ * figures after it, which suits a long narrative; a split one puts the figures
+ * beside the account, which suits a reader who came for the number. The Block
+ * does not choose between them and does not decide how many figures fit either
+ * way, so a caller with five figures gets five figures in both.
+ *
+ * The section title is `title` when given and the customer's name otherwise, and
+ * the customer's name is drawn in the body either way. The section is the one
+ * place in this package where the heading is a claim about a third party, which
+ * is why the name is a required prop and never a default: there is no anonymous
+ * case study here, and a generic label standing in for a name would be an
+ * advertisement rather than a study.
+ *
+ * It is a server Component: no hook, no state and no client code. `useId` is the
+ * one React call it makes, and it is the call the server render supports, which
+ * `ListPanel`, `FilterPanel` and `FileUpload` already depend on.
+ */
+export function CaseStudy01({ eyebrow, title, customer, sector, summary, problem, approach, results, quote, quoteLabel, actions, layout = 'stacked', headingLevel = 'h2', className, }) {
+    const quoteId = useId();
+    const account = (_jsxs(_Fragment, { children: [problem === undefined ? null : (_jsx(Prose, { "data-slot": "case-study-problem", children: problem })), approach === undefined ? null : (_jsx(Prose, { "data-slot": "case-study-approach", children: approach }))] }));
+    const figures = results.length === 0 ? null : (_jsx("div", { "data-slot": "case-study-results", className: "border-border grid gap-6 border-y py-8 sm:grid-cols-2 lg:grid-cols-3", children: results.map((result, index) => (_jsx(Metric, { "data-result": result.label, value: result.value, label: result.label, delta: result.delta, hint: result.hint }, `${result.label}-${index}`))) }));
+    const quotation = quote === undefined ? null : (_jsxs("figure", { "data-slot": "case-study-quote", "aria-labelledby": quoteId, className: "flex flex-col gap-3", children: [_jsx("span", { id: quoteId, className: "sr-only", children: quoteLabel }), _jsx("blockquote", { "data-slot": "case-study-quotation", className: "text-balance text-lg font-medium text-pretty sm:text-xl", children: quote.quote }), _jsxs("figcaption", { "data-slot": "case-study-attribution", className: "flex flex-col gap-0.5 text-sm", children: [_jsx("span", { className: "font-medium", children: quote.name }), quote.role === undefined ? null : (_jsx("span", { className: "text-muted-foreground", children: quote.role }))] })] }));
+    return (_jsxs(Section, { className: className, children: [_jsx(SectionHeading, { as: headingLevel, align: "left", eyebrow: eyebrow, title: title ?? customer, className: "mb-8" }), _jsxs("div", { "data-slot": "case-study", "data-layout": layout, className: cn(layout === 'split' ? 'flex flex-col gap-10 lg:grid lg:grid-cols-3 lg:gap-12' : 'flex flex-col gap-10'), children: [_jsxs("div", { "data-slot": "case-study-account", className: cn('flex flex-col gap-6', layout === 'split' ? 'lg:col-span-2' : ''), children: [_jsxs("div", { "data-slot": "case-study-meta", className: "flex flex-wrap items-center gap-3", children: [_jsx("span", { "data-slot": "case-study-customer", className: "text-sm font-semibold", children: customer }), sector === undefined ? null : (_jsx(Badge, { variant: "outline", "data-sector": sector, children: sector }))] }), _jsx("p", { "data-slot": "case-study-summary", className: "max-w-measure text-lg text-pretty", children: summary }), account] }), _jsxs("div", { "data-slot": "case-study-evidence", className: "flex flex-col gap-8", children: [figures, quotation] })] }), actions === undefined ? null : (_jsx("div", { "data-slot": "case-study-actions", className: "mt-10 flex flex-wrap items-center gap-3", children: actions }))] }));
+}
+export default CaseStudy01;

package/dist/blocks/case-study-01/index.d.ts

@@ -0,0 +1,3 @@
+export { CaseStudy01, default } from './case-study.js';
+export type { CaseStudy01Props, CaseStudy01Result, CaseStudy01Quote } from './case-study.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blocks/case-study-01/index.d.ts.map

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

package/dist/blocks/case-study-01/index.js

@@ -0,0 +1 @@
+export { CaseStudy01, default } from './case-study.js';

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

@@ -0,0 +1,200 @@
+import type { ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * The five kinds a change record can be, and the closed set is the taxonomy.
+ *
+ * A taxonomy and not a severity ladder, and the difference decides the tones
+ * below. A change record says what kind of change it is; it does not say how bad
+ * it was, because "bad" is a property of a reader's exposure rather than of the
+ * record. A security fix in a package nobody installed is not more urgent than a
+ * typo fix in the package everybody did, and the record cannot tell the two apart.
+ * So these are the kinds and the words are the kinds.
+ */
+export type Changelog01Kind = 'added' | 'changed' | 'fixed' | 'removed' | 'security';
+/**
+ * One change record inside a release: a kind, a title, and the sentence or two
+ * that say what changed.
+ *
+ * `kind` and `title` are required, and a record with neither is a line in a list
+ * a reader has to interpret. `body` is optional because half of what a changelog
+ * publishes is a one line record: "Dropped the deprecated `mode` prop", which is
+ * complete on its own and would be worse with a sentence under it.
+ */
+export type Changelog01Entry = {
+    /** The record's stable key within its release. */
+    id: string;
+    /** Which of the five kinds this record is. */
+    kind: Changelog01Kind;
+    /** The one line that says what changed. */
+    title: string;
+    /**
+     * The detail under the line: why it changed, what it affects, what to do about
+     * it. A node, so a caller may pass a paragraph, a list of migration steps, or a
+     * `CodeBlock` showing the old and the new call side by side.
+     */
+    body?: ReactNode;
+    /** Where the full record lives. Its presence makes the entry carry a link. */
+    href?: string;
+    /**
+     * The words on the link, and required whenever `href` is.
+     *
+     * A link whose only words are the entry's own title tells a reader nothing about
+     * what following it does, and the same rule holds here as in every other Block
+     * that draws one.
+     */
+    hrefLabel?: string;
+};
+/**
+ * One release: what it is called, when it was, one line about it, and its records.
+ *
+ * `version` and `entries` are required and `at` is not, because a changelog is
+ * grouped by release in one product and by date in another, and a date is a fact
+ * about the release rather than part of its identity. `1.4.0` and `2026-09-30` are
+ * both legitimate things to print where a version goes, and the Block prints the
+ * string it was handed in the mono face because both are machine notation.
+ */
+export type Changelog01Release = {
+    /** The release's stable key within the set. */
+    id: string;
+    /**
+     * The version, or the date, or whatever identifies this group of records, as the
+     * product writes it.
+     */
+    version: string;
+    /** The moment, as a string. Printed verbatim; see `ContentGrid01Entry`'s `at`. */
+    at?: string;
+    /** One line about the release as a whole, for a reader deciding whether to read on. */
+    summary?: ReactNode;
+    /**
+     * The records, in the order the product published them.
+     *
+     * Order is the caller's, and a changelog is one of the two surfaces in this
+     * system where the order is genuinely a claim: a security fix belongs next to
+     * the change that made it necessary far more often than it belongs at the top of
+     * the list.
+     */
+    entries: Changelog01Entry[];
+};
+/**
+ * The props a Changelog01 takes.
+ *
+ * Every string is a prop and the Block ships none: no version, no date, no kind
+ * word, no title, no body and no link label. A changelog is the highest risk of
+ * hardcoded copy in this package, because the vocabulary of change is the most
+ * tempting kind of copy to write: five words, a fixed order, and every product
+ * apparently needs them. Five words in English is five words every consumer of
+ * this Block inherits, and the corpus publishes them as the design system's own.
+ */
+export type Changelog01Props = {
+    /** Optional label above the section title. See the No-Default-Eyebrow Rule. */
+    eyebrow?: string;
+    /** The section title. Omit it for a changelog composed under its own heading. */
+    title?: string;
+    /** One or two sentences under the title. */
+    description?: string;
+    /**
+     * The releases, newest first unless the product says otherwise.
+     *
+     * The Block does not sort. A changelog's order is a publication decision with a
+     * long tail of exceptions, and a Block that sorted by version string would
+     * reorder `1.10.0` before `1.9.0` for every consumer whose versions are strings.
+     */
+    releases: Changelog01Release[];
+    /**
+     * Whether each record carries its kind mark.
+     *
+     * @defaultValue true
+     *
+     * On by default because a reader scanning a page of releases is usually looking
+     * for one kind and not reading all of them. Pass `false` where the release's own
+     * summary already says what kind of release it was, or where the records are
+     * written so that the title alone identifies them, which is the case for a
+     * product that publishes two records per release and no more.
+     */
+    showKinds?: boolean;
+    /** Heading level for the section title. See `HeadingLevel`. */
+    headingLevel?: HeadingLevel;
+    /**
+     * Layout only, exactly as on every Block. Changing a Prism-owned visual
+     * property from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * A dated record of what changed, grouped by release, each record carrying a
+ * version, a kind, a line about what changed, and the sentence under it.
+ *
+ * **The five kinds and their tones are stated out loud in the `KIND_TONE` note
+ * above, and `security` takes `warning` rather than `destructive`, and the reason
+ * is the one thing a Block cannot know.** Severity is the reader's judgement, not
+ * the record's property. A `security` entry is the only one of the five that
+ * carries an implied claim about urgency, and a design system that coloured it
+ * destructively would be making that claim for every consumer in every release
+ * for ever. The concrete cost is easy to name: a product that publishes a routine
+ * dependency bump under `security` would have a red dot on it, and a reader
+ * trained by that page would learn to skip the red, and the day the product had a
+ * real advisory there would be nothing louder left to spend. The other side of
+ * that is the cost of `warning` and it is worth naming too: a consumer who needs a
+ * genuinely serious advisory to be unmistakable has no louder mark available to
+ * them, because the tone is fixed by the kind. The answer is that a serious
+ * advisory is a sentence, and the sentence is the `title` and the `body` the
+ * caller wrote. A design system has no standing to decide how alarming a
+ * consumer's release history is.
+ *
+ * **The kind is the taxonomy and the tones are the Block's, and neither is the
+ * caller's words.** The five kinds are closed because they are a vocabulary of
+  change that a reader learns once and then scans by, and a per-product vocabulary
+ * would be a column no reader could scan. What the caller owns is the tone's
+ * absence or presence and the sentence beside the mark, which is why the mark is
+ * `Status` and not a `Badge`: `Status` takes a tone and a label, its dot is
+  `aria-hidden`, and the label carries the meaning, so a reader who cannot separate
+  * `warning` from `neutral` still hears which kind each record is. The five words
+  * themselves are rendered from the value the caller passed, which is what a tier
+  * is: a machine value in a closed set, drawn as it was given, exactly as a
+ * version, a file name or a tier in any other Block is drawn.
+ *
+ * **The outline is section, then release, then record, and all three levels are
+ * derived.** A release is a heading one step below the section and a record is a
+ * heading one step below the release, which is `childLevel` applied twice rather
+ * than a literal `h3` in either place. The reason the record is not a sibling of
+ * the release is the shape of the data: a changelog is a set of groups, and a
+ * reader who navigates by heading is looking for a version, and then for a record
+ * inside it. A changelog with forty records directly under the section is an
+ * outline of forty peers and no grouping, which is a list of flat entries and not
+ * a record of releases. The cost is real: a reader on a page with a hundred
+  * releases meets a hundred headings before any record, which is the price of a
+ * structure they can jump through and the price a `Story01` already pays.
+ *
+ * **A release with no records draws its version and its date and no list.** An
+ * empty array is a legitimate state rather than a gap: a release that was cut
+  before anything landed, a release whose records were all withdrawn, a milestone
+  with a name and nothing under it. What it must not draw is a frame. A bordered
+  empty group under a version reads as content that failed to load, which is the
+ * one thing a changelog must never suggest about a release, and a
+ * "no changes" line would be a sentence Prism does not have the standing to
+ * write, because whether an empty release is a mistake or a policy is the
+ * product's business. So the list element is not drawn at all, and the release
+  * reads as a version with nothing under it, which is what it is.
+ *
+ * **A release is one `section`-less group of the section it sits in, and the
+ * versions are a list.** The releases are drawn in a `div` rather than a nested
+ * `<section>` because a `<section>` is a landmark and forty landmarks with no
+ * accessible name is forty announcements of nothing; the version is the heading and
+ * the heading is the name. The records inside a release are one `ul`, so a reader
+ * hears one list per release rather than one list for the page, and a list that
+ * spans a group boundary is a list whose items are not all the same kind of thing.
+ *
+ * **A record with no link draws no link, and one with a link carries the caller's
+ * words.** The pair is checked before anything is drawn, the same refusal
+ * `ContentGrid01` makes and for the same reason, and the message names the field.
+ * A per-record link is the difference between a changelog and a set of titles: it
+ * is where a reader goes for the migration steps, the diff, or the issue, and a
+ * changelog that cannot link out is a list of assertions.
+ *
+ * It is a server Component: no hook, no state and no client code. A consumer that
+ * wants a record's body to hold a control composes the control itself in `body`,
+ * which is the arrangement a `ReactNode` slot exists for.
+ */
+export declare function Changelog01({ eyebrow, title, description, releases, showKinds, headingLevel, className, }: Changelog01Props): import("react").JSX.Element | null;
+export default Changelog01;
+//# sourceMappingURL=changelog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"changelog.d.ts","sourceRoot":"","sources":["../../../src/blocks/changelog-01/changelog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,OAAO,EAAuC,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAIpG;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAA;AA0DpF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,8CAA8C;IAC9C,IAAI,EAAE,eAAe,CAAA;IACrB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAA;IACV;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,kFAAkF;IAClF,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,uFAAuF;IACvF,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;;;OAOG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAA;CAC5B,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;OAMG;IACH,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,KAAK,EACL,WAAW,EACX,QAAQ,EACR,SAAgB,EAChB,YAAmB,EACnB,SAAS,GACV,EAAE,gBAAgB,sCAoHlB;AAED,eAAe,WAAW,CAAA"}