@nanisoft/prism-ui 0.10.2 → 0.15.0

package/dist/pages/careers-page/index.js

@@ -0,0 +1,182 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Careers01 } from '../../blocks/careers-01/index.js';
+import { ContentGrid01 } from '../../blocks/content-grid-01/index.js';
+import { CtaLink } from '../../components/ui/cta-link.js';
+import { Section, SectionHeading, childLevel } from '../../components/ui/section.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * A complete careers screen: who the company is, what it is hiring for, what it
+ * believes, who you would work with, what you would get, and where to send
+ * something.
+ *
+ * **The decision that makes this a Page rather than a `Careers01` is the empty
+ * state, and the Page makes it by refusing to branch on it.** A careers page with
+ * no open roles is one of the two states a careers page is always in, and it is
+ * the one a list is worst at: a list that renders nothing has told a reader
+ * nothing at all, and a route that 404s on the week a company closes its last
+ * vacancy is a route that fails exactly when somebody is most likely to be
+ * checking. So the roles band is not conditional here. It is always rendered, and
+ * it is always given `empty`, so it draws the caller's own sentence in place of the
+ * rows and the rest of the screen is unchanged around it. A consumer reading this
+ * page in a week with no vacancies still learns what the company is, what it
+ * believes, who they would work with and where to send a CV, which is the only
+ * thing a careers page is for. The rejected alternative was a `roles.length > 0`
+ * branch around the band, and it is the exact failure `ContentGrid01` and
+ * `Community01` each refuse in their own way: a section that is not there is a
+ * section a reader cannot tell from a section that failed to load.
+ *
+ * **The page heading is the roles band's own heading, and that is `Careers01`'s
+ * design rather than this Page's.** The band requires a title precisely because a
+ * page that lists roles without saying why it exists reads as a job board, so the
+ * page's `h1` is the one that does the saying and the Page draws no heading of its
+ * own above it. A Page that drew its own title and then handed the band a second
+ * one would say the same words twice within one screen, and the duplicate is the
+ * kind of thing no gate finds and every reader sees.
+ *
+ * **The order after the roles band is the order a reader asks the rest of it in.**
+ * Values, then teams, then benefits, then the way on. "What do you believe" comes
+ * before "who would I work with" because a team is a group of people a reader has
+ * to have a reason to care about, and it comes before the benefits because a
+ * benefit is a promise that needs the belief behind it to be worth reading. The
+ * cost is that a consumer who hires into one team only would want that band first,
+ * and the answer is the one the about page gives: the bands after the roles are
+ * each optional, and a consumer who wants a different order composes the screen
+ * from `ContentGrid01` itself.
+ *
+ * **The values, the teams and the benefits are the same Block three times, and
+ * that is a decision rather than a shortage.** Each is a set of titled things with
+ * a sentence under it and nothing else: no date, no figure, no status. A Page
+ * that drew them three different ways would be inventing differences its data does
+ * not contain, and the only difference between them here is the arrangement, which
+ * is what the `rows` form is for: a team is a set a reader compares, and a value
+ * and a benefit are sets a reader chooses from. The cost is that three consecutive
+ * bands share a frame, and the answer is that a consumer with a band of its own
+ * composes it in place of the one that is not doing the job.
+ *
+ * **The Page takes one function prop and it never crosses a boundary.** `rolesLabel`
+ * is a function because a count is a number and the words for it are a sentence
+ * the consumer writes in its own language, and because no two languages word a
+ * count the same way. It is called here, during this render, and what is handed
+ * down is the string it returned: a server Component may hold a function and call
+ * it, and what it may not do is pass one to a client Component, which is why
+ * nothing on this page receives a callback. Every one of the composed Blocks is a
+ * server Component, so the screen costs a consumer no client JavaScript at all.
+ *
+ * **The two checks that run before anything is drawn are the ones that would
+ * otherwise be invisible in a screenshot.** A role with an `href` and no
+ * `hrefLabel` renders a link announced by its address, and a narrowing row with no
+ * accessible name is a landmark announced as nothing, which is the state a screen
+ * reader user is least able to recover from. The Page throws on both, naming its
+ * own props, and the cost of throwing is that a JavaScript caller with a data file
+ * that has drifted finds out at render rather than in review.
+ *
+ * It is a server Component. It fetches nothing, it holds no state and it imports
+ * no router, so a consumer renders it from whichever route their framework names
+ * for the careers page and hands it the roles their own system published.
+ */
+export function CareersPage({ eyebrow, title, description, roles, closedLabel, values, teams, benefits, openings, openingsLabel, contact, empty, headingLevel = 'h1', className, }) {
+    assertLabels(roles, teams);
+    const narrowing = asNarrowing(openings, openingsLabel);
+    return (_jsxs("div", { "data-slot": "careers-page", className: cn(className), children: [_jsx(Careers01, { eyebrow: eyebrow, title: title, description: description, roles: roles.map(asRole), filters: narrowing, empty: empty, closedLabel: closedLabel, headingLevel: headingLevel }), values === undefined || values.length === 0 ? null : (_jsx(ContentGrid01, { entries: values.map((value) => ({ id: value.id, title: value.title, summary: value.body })), headingLevel: headingLevel })), teams === undefined || teams.length === 0 ? null : (_jsx(ContentGrid01, { variant: "rows", entries: teams.map((team) => ({
+                    id: team.id,
+                    title: team.name,
+                    summary: teamSummary(team),
+                })), headingLevel: headingLevel })), benefits === undefined || benefits.length === 0 ? null : (_jsx(ContentGrid01, { entries: benefits.map((benefit) => ({
+                    id: benefit.id,
+                    title: benefit.title,
+                    summary: benefit.body,
+                })), headingLevel: headingLevel })), contact === undefined ? null : (_jsxs(Section, { "data-slot": "careers-page-contact", children: [_jsx(SectionHeading, { as: childLevel(headingLevel), align: "left", title: contact.title, description: contact.description, className: "mb-8" }), _jsx(CtaLink, { href: contact.href, children: contact.hrefLabel })] }))] }));
+}
+/**
+ * The narrowing row, or nothing at all.
+ *
+ * A `nav` rather than a list of links on their own, because a row of links that
+ * filters a list is a landmark: a screen reader user who lands on the page and
+ * jumps to navigation expects to be told what the region is. The accessible name
+ * is the caller's, and the check in the same function is why that name is owed
+ * rather than optional: a `nav` with no name is announced as "navigation", which
+ * on a page with a site header above it is two regions called the same thing and
+ * nothing to tell them apart.
+ */
+function asNarrowing(openings, openingsLabel) {
+    if (openings === undefined || openings.length === 0)
+        return null;
+    if (openingsLabel === undefined || openingsLabel.trim() === '') {
+        throw new Error('CareersPage: openings were passed with no openingsLabel, so the row would be a navigation landmark announced ' +
+            'as nothing in particular, which is the one region on a page a screen reader user cannot then identify. Pass ' +
+            'the words that say what the row narrows, or drop the openings.');
+    }
+    return (_jsx("nav", { "aria-label": openingsLabel, className: "flex flex-wrap items-center gap-3", children: openings.map((opening) => (_jsx(CtaLink, { href: opening.href, variant: "outline", size: "sm", children: opening.label }, opening.href))) }));
+}
+/**
+ * One team as a row draws it, with the count under the detail rather than beside
+ * the name.
+ *
+ * A count is a reading and not a name, so it belongs in the row's body where the
+ * detail is and not in the row's heading where a reader scanning names would meet
+ * a number with no noun beside it. The span is given `block` and nothing else, so
+ * the count is a second line at the summary's own size rather than a smaller
+ * annotation this Page invented a size for.
+ */
+function teamSummary(team) {
+    const counted = team.roles === undefined ? null : (team.rolesLabel?.(team.roles, team.name) ?? null);
+    if (team.detail === undefined)
+        return counted;
+    if (counted === null)
+        return team.detail;
+    return (_jsxs(_Fragment, { children: [team.detail, _jsx("span", { className: "block", children: counted })] }));
+}
+/**
+ * One role as the list draws it, with the two link arms kept apart.
+ *
+ * The same seam the about page draws at its engagements: a consumer's role record
+ * is flat, and the pair is built once here rather than narrowed at every record.
+ * The `hrefLabel` fallback is unreachable, because the check above throws first,
+ * and it is written as an empty string rather than as an assertion so a future
+ * change in the order would render an unnamed link rather than lie to the
+ * compiler.
+ */
+function asRole(role) {
+    const shared = {
+        id: role.id,
+        title: role.title,
+        team: role.team,
+        location: role.location,
+        pattern: role.pattern,
+        summary: role.summary,
+        postedAt: role.postedAt,
+        closed: role.closed,
+    };
+    return role.href === undefined
+        ? shared
+        : { ...shared, href: role.href, hrefLabel: role.hrefLabel ?? '' };
+}
+/**
+ * The two checks the Page owes its own reader before anything is drawn, run once
+ * here so the messages name the Page's own props.
+ *
+ * A role with an `href` and no `hrefLabel` renders a link announced by its address,
+ * and a team with a `roles` count and no `rolesLabel` renders a bare numeral beside
+ * a name, which tells a screen reader nothing about what it counts. `Careers01`
+ * throws for the first of those on its own account and `ContentGrid01` cannot see
+ * the second at all, so the second exists here. The cost of throwing rather than
+ * degrading is that a caller with a data file that has drifted finds out at render
+ * instead of in review, which is the trade every refusal in this package makes.
+ */
+function assertLabels(roles, teams) {
+    for (const role of roles) {
+        if (role.href !== undefined && (role.hrefLabel === undefined || role.hrefLabel.trim() === '')) {
+            throw new Error('CareersPage: a role declares an href and no hrefLabel, so the row would carry a link announced by its ' +
+                'address, which a screen reader reads out as punctuation rather than as a name. Pass the words that say ' +
+                'what following the link does, or drop the href.');
+        }
+    }
+    for (const team of teams ?? []) {
+        if (team.roles !== undefined && (team.rolesLabel === undefined || team.rolesLabel === null)) {
+            throw new Error('CareersPage: a team declares a roles count and no rolesLabel, so the reading would be a bare numeral ' +
+                'beside a team name, which tells a screen reader nothing about what it counts and a sighted reader only ' +
+                'that somebody counted. Pass the words for the count in your own language, or drop the count.');
+        }
+    }
+}
+export default CareersPage;

package/dist/pages/changelog-page/index.d.ts

@@ -0,0 +1,255 @@
+import type { ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * One change record inside a release: which kind it is, the line that says what
+ * changed, and the sentence under it.
+ *
+ * `kind` is a closed set of five and it is the taxonomy rather than a severity
+ * ladder: a record says what kind of change it is and not how bad it was, because
+ * how bad it was is a property of a reader's exposure and not of the record. The
+ * words beside the mark are the caller's, and the mark itself is the Block's.
+ */
+export type ChangelogPageRecord = {
+    /** The record's stable key within its release. */
+    id: string;
+    /** Which of the five kinds this record is. */
+    kind: 'added' | 'changed' | 'fixed' | 'removed' | 'security';
+    /** 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
+     * code block showing the old call beside the new one.
+     */
+    body?: ReactNode;
+    /** Where the full record lives. Its presence makes the entry carry a link. */
+    href?: string;
+    /** The words on the link. Required whenever `href` is, and enforced by the Block. */
+    hrefLabel?: string;
+};
+/**
+ * One release: what it is called, when it was, one line about it, and its records.
+ *
+ * **`version` and `at` are two different facts and both are required by different
+ * readers, which is why neither is derived from the other.** A product that cuts
+ * a nightly build has a moment and no meaningful version, and a product that ships
+ * once a month has a version a reader can compare against their own lockfile and
+ * almost no use for the hour. The Page prints what it was handed and invents
+ * neither: it holds no calendar, no semver parser and no opinion about which of
+ * the two identifies a release, because every product in this repository has
+ * answered that differently and the one answer that would fit all of them is the
+ * string the caller already had.
+ */
+export type ChangelogPageRelease = {
+    /**
+     * The release's stable key, and the fragment a consumer's own changelog links
+     * to.
+     *
+     * A key and not the version, because a fragment has to be a legal anchor and
+     * `1.4.0` and `Q3 2026` are not the same shape of string. The Page puts it on
+     * the element that wraps the release's own heading, so a link to it lands on the
+     * release rather than above it.
+     */
+    id: string;
+    /** The version, or the date, or whatever identifies this group of records. */
+    version: string;
+    /** The moment, already written the way a reader should see it. */
+    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 this Page never touches it. A changelog is a record
+     * rather than a document, and the order in a record is the order things happened
+     * in, which is a publication decision with a long tail of exceptions: a security
+     * fix belongs beside the change that made it necessary far more often than it
+     * belongs at the top of the list. Sorting by the version string would reorder
+     * `1.10.0` before `1.9.0` for every consumer whose versions happen to be
+     * strings, and sorting by the date would move a release whose records were
+     * written in a different order into one that was not.
+     */
+    entries: readonly ChangelogPageRecord[];
+};
+/**
+ * One kind the reader can ask for, and whether they have.
+ *
+ * `state` is a state and not a control: it is what the caller has decided, and the
+ * Page draws it. The control that changes it is the caller's, in `filters`,
+ * because narrowing a changelog means holding state and a server Page holds none.
+ */
+export type ChangelogPageFilter = {
+    /** A stable key for the filter. */
+    id: string;
+    /** The words on the filter, in the product's own language. */
+    label: string;
+    /** Whether the caller has this kind turned on. */
+    state: 'on' | 'off';
+};
+/**
+ * The band that asks a reader to stop reading and start receiving.
+ *
+ * `cta` is a node rather than a label and a destination because the thing a reader
+ * subscribes to is a control: an email field, a feed link, a form the consumer
+ * wrote. Prism supplies the heading and the measure and the caller supplies the
+ * control, which is the same seam every other slot in this package is.
+ */
+export type ChangelogPageSubscribe = {
+    /** The band's heading. */
+    title: ReactNode;
+    /** One or two sentences under the heading. */
+    description?: ReactNode;
+    /** The control that subscribes the reader, composed by the caller. */
+    cta: ReactNode;
+};
+/**
+ * The props a ChangelogPage takes.
+ *
+ * Every string, every version and every record is a prop and the Page ships none
+ * of them. 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 one
+ * language is five words every consumer of this Page inherits, and the corpus
+ * publishes them as this design system's own.
+ */
+export type ChangelogPageProps = {
+    /** Optional label above the page's own heading. See the No-Default-Eyebrow Rule. */
+    eyebrow?: string;
+    /**
+     * The page's heading.
+     *
+     * Required, and the Page draws it itself rather than handing it to the first
+     * release. See the Page's JSDoc for the state that decided it.
+     */
+    title: ReactNode;
+    /** One or two sentences under the heading. */
+    description?: ReactNode;
+    /**
+     * The releases, newest first unless the product says otherwise.
+     *
+     * The Page does not sort them and does not filter them. Order is a publication
+     * decision, and which releases are shown at all is a decision about the reader.
+     */
+    releases: readonly ChangelogPageRelease[];
+    /**
+     * The kinds the reader can ask for, and which of them they have.
+     *
+     * Drawn as a legend rather than as a row of controls, because a control that
+     * does nothing is worse than no control: this Page is a server Component, it
+     * holds no state, and a button on it would be a button a reader presses and
+     * nothing happens.
+     */
+    kinds?: readonly ChangelogPageFilter[];
+    /**
+     * The filter control itself: a `TagGroup`, a set of `Button`s wired to a query
+     * the caller fetches, or a set of links under a query parameter.
+     *
+     * A slot because a filter is a control and this Page ships no behaviour. The
+     * narrowed set comes back through `releases`, which is why the Page never has to
+     * know what the control did.
+     */
+    filters?: ReactNode;
+    /**
+     * The caller's own way of reaching the releases that are not on this page: a
+     * load-more control, a pager, a link to an archive route.
+     *
+     * A slot for the same reason `filters` is one, and for one more: pagination is
+     * a routing decision. Whether the next page is a query parameter, a path
+     * segment or a second fetch is a fact about the consumer's own router, and a
+     * Page that drew a pager would have drawn a router.
+     */
+    older?: ReactNode;
+    /** The closing band asking the reader to subscribe. Omit it and the page ends at `older`. */
+    subscribe?: ChangelogPageSubscribe;
+    /**
+     * What the page shows instead of the releases when there are none.
+     *
+     * Required, and for the same reason the empty state is required on a careers
+     * page: a product that has not shipped yet still has a changelog route, and a
+     * route that draws nothing is a route a reader cannot tell from a broken one.
+     */
+    empty: ReactNode;
+    /**
+     * The heading level for the page's own heading, and one step below it for every
+     * band and for every release heading inside those bands.
+     *
+     * Defaults to `h1`, because a page owns the top of the document outline.
+     */
+    headingLevel?: HeadingLevel;
+    /**
+     * Layout only, exactly as on every Component. Changing a Prism-owned visual
+     * property from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * A complete record screen: what changed, in the order it changed, with the
+ * reader's own way of narrowing it and the product's own way of reaching the rest
+ * of it.
+ *
+ * **It composes one `Changelog01` per release, and that is the first thing a Block
+ * cannot do for itself.** A changelog is a record rather than a document, and the
+ * difference is not a matter of taste: a document has one reading order that a
+ * reader follows from the top, and a record has an order that is a claim about
+ * what happened, which is why the Block takes the order it is given and refuses to
+ * sort. A page that passed the whole set to one Block would have every release
+ * inside a single section, and the cost of that is the second thing this Page
+ * exists for. Composing one per release gives each release its own band and its
+ * own anchor, and the alternative was a `Section` per release written here, which
+ * would have meant re-deriving the container and the rhythm that `Section` owns.
+ *
+ * **Each release is linkable, and the release's own heading is what the link
+ * lands on.** This is the page a product points at when it says "since last time":
+ * an email, a status dashboard, a support answer and a customer's own release
+ * notes all want to send a reader to one release rather than to the top of a list
+ * they then have to scroll. So the caller's `id` goes on the element that wraps
+ * each release, the release's heading is the first thing in it, and a fragment link
+ * to that id lands on the release rather than a band above it. The Page uses the
+ * release's key rather than its version for the anchor, because a fragment has to
+ * be legal in a URL and `1.4.0` and `Q3 2026` are not the same shape of string;
+ * the cost is that a consumer writing a link by hand has to use the key, which is
+ * why the key is a required field and not derived from the version.
+ *
+ * **The filters and the older-entries slot are the caller's, and the reason is that
+ * both are facts about the reader.** A changelog is usually longer than anyone will
+ * read, and a reader who wants only the security records and the reader who wants
+ * only the ones since their last deploy are asking two different questions of the
+ * same page, so the control that asks it belongs to whoever knows the answer.
+ * Filtering also means holding state, and a server Page holds none, which is why
+ * `filters` is a node the caller fills with a control they wired themselves and
+ * `kinds` is a legend this Page draws from the state they reported: a row of
+ * pressed-looking marks with no way to press them would be a row of lies, and the
+ * legend is the honest form of the same information. `older` is a slot for the
+ * same reason plus one more, which is that pagination is a routing decision:
+ * whether the next page is a query parameter, a path segment or a second fetch is
+ * a fact about the consumer's router, and a Page that drew a pager would have drawn
+ * a router.
+ *
+ * **The page draws its own `h1`, and the state that decided it is the empty one.**
+ * The alternative was handing the caller's title to the first `Changelog01`, which
+ * is what the about page and the careers page do with their first band, and it was
+ * rejected because `Changelog01` returns nothing at all when it is given no
+ * releases. A product that has not shipped yet, or a product whose first release
+ * is being written right now, still has a changelog route, and on that route the
+ * heading would have been inside the one element that does not render, so the
+ * screen would have had no `h1`, no title, and a sentence about there being no
+ * releases floating under nothing. The Page therefore holds the heading itself, in
+ * a band of its own, and every release below it is composed at one level deeper
+ * with no title, which is also why a release's heading is a child of the page
+ * rather than a sibling of it.
+ *
+ * **`empty` is required and it is not the same prop as the one a Block would want.**
+ * The honest sentence for a changelog with nothing in it is a fact about the
+ * product and not about a changelog: "no releases yet" and "your filter matched
+ * nothing" want different words, and only the caller knows which one they are
+ * showing. So the Page takes the node and draws it in the release band's place, in
+ * a band of its own so the reader is told the record is empty rather than being
+ * shown a gap where it should be.
+ *
+ * It is a server Component. It fetches nothing, it holds no state, it takes no
+ * function prop and it imports no router, so a consumer renders it from their own
+ * changelog route and hands it the releases their release pipeline published.
+ */
+export declare function ChangelogPage({ eyebrow, title, description, releases, kinds, filters, older, subscribe, empty, headingLevel, className, }: ChangelogPageProps): import("react").JSX.Element;
+export default ChangelogPage;
+//# sourceMappingURL=index.d.ts.map

package/dist/pages/changelog-page/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pages/changelog-page/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAItC,OAAO,EAAuC,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAGpG;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,8CAA8C;IAC9C,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAA;IAC5D,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;OAQG;IACH,EAAE,EAAE,MAAM,CAAA;IACV,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAA;IACf,kEAAkE;IAClE,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,uFAAuF;IACvF,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;;;;;;;OAWG;IACH,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAA;CACxC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAA;IACb,kDAAkD;IAClD,KAAK,EAAE,IAAI,GAAG,KAAK,CAAA;CACpB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,0BAA0B;IAC1B,KAAK,EAAE,SAAS,CAAA;IAChB,8CAA8C;IAC9C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB,sEAAsE;IACtE,GAAG,EAAE,SAAS,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;OAKG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB,8CAA8C;IAC9C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;;OAKG;IACH,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAA;IACzC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACtC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,6FAA6F;IAC7F,SAAS,CAAC,EAAE,sBAAsB,CAAA;IAClC;;;;;;OAMG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,KAAK,EACL,WAAW,EACX,QAAQ,EACR,KAAK,EACL,OAAO,EACP,KAAK,EACL,SAAS,EACT,KAAK,EACL,YAAmB,EACnB,SAAS,GACV,EAAE,kBAAkB,+BA2EpB;AAED,eAAe,aAAa,CAAA"}

package/dist/pages/changelog-page/index.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Changelog01 } from '../../blocks/changelog-01/index.js';
+import { Badge } from '../../components/ui/badge.js';
+import { Section, SectionHeading, childLevel } from '../../components/ui/section.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * A complete record screen: what changed, in the order it changed, with the
+ * reader's own way of narrowing it and the product's own way of reaching the rest
+ * of it.
+ *
+ * **It composes one `Changelog01` per release, and that is the first thing a Block
+ * cannot do for itself.** A changelog is a record rather than a document, and the
+ * difference is not a matter of taste: a document has one reading order that a
+ * reader follows from the top, and a record has an order that is a claim about
+ * what happened, which is why the Block takes the order it is given and refuses to
+ * sort. A page that passed the whole set to one Block would have every release
+ * inside a single section, and the cost of that is the second thing this Page
+ * exists for. Composing one per release gives each release its own band and its
+ * own anchor, and the alternative was a `Section` per release written here, which
+ * would have meant re-deriving the container and the rhythm that `Section` owns.
+ *
+ * **Each release is linkable, and the release's own heading is what the link
+ * lands on.** This is the page a product points at when it says "since last time":
+ * an email, a status dashboard, a support answer and a customer's own release
+ * notes all want to send a reader to one release rather than to the top of a list
+ * they then have to scroll. So the caller's `id` goes on the element that wraps
+ * each release, the release's heading is the first thing in it, and a fragment link
+ * to that id lands on the release rather than a band above it. The Page uses the
+ * release's key rather than its version for the anchor, because a fragment has to
+ * be legal in a URL and `1.4.0` and `Q3 2026` are not the same shape of string;
+ * the cost is that a consumer writing a link by hand has to use the key, which is
+ * why the key is a required field and not derived from the version.
+ *
+ * **The filters and the older-entries slot are the caller's, and the reason is that
+ * both are facts about the reader.** A changelog is usually longer than anyone will
+ * read, and a reader who wants only the security records and the reader who wants
+ * only the ones since their last deploy are asking two different questions of the
+ * same page, so the control that asks it belongs to whoever knows the answer.
+ * Filtering also means holding state, and a server Page holds none, which is why
+ * `filters` is a node the caller fills with a control they wired themselves and
+ * `kinds` is a legend this Page draws from the state they reported: a row of
+ * pressed-looking marks with no way to press them would be a row of lies, and the
+ * legend is the honest form of the same information. `older` is a slot for the
+ * same reason plus one more, which is that pagination is a routing decision:
+ * whether the next page is a query parameter, a path segment or a second fetch is
+ * a fact about the consumer's router, and a Page that drew a pager would have drawn
+ * a router.
+ *
+ * **The page draws its own `h1`, and the state that decided it is the empty one.**
+ * The alternative was handing the caller's title to the first `Changelog01`, which
+ * is what the about page and the careers page do with their first band, and it was
+ * rejected because `Changelog01` returns nothing at all when it is given no
+ * releases. A product that has not shipped yet, or a product whose first release
+ * is being written right now, still has a changelog route, and on that route the
+ * heading would have been inside the one element that does not render, so the
+ * screen would have had no `h1`, no title, and a sentence about there being no
+ * releases floating under nothing. The Page therefore holds the heading itself, in
+ * a band of its own, and every release below it is composed at one level deeper
+ * with no title, which is also why a release's heading is a child of the page
+ * rather than a sibling of it.
+ *
+ * **`empty` is required and it is not the same prop as the one a Block would want.**
+ * The honest sentence for a changelog with nothing in it is a fact about the
+ * product and not about a changelog: "no releases yet" and "your filter matched
+ * nothing" want different words, and only the caller knows which one they are
+ * showing. So the Page takes the node and draws it in the release band's place, in
+ * a band of its own so the reader is told the record is empty rather than being
+ * shown a gap where it should be.
+ *
+ * It is a server Component. It fetches nothing, it holds no state, it takes no
+ * function prop and it imports no router, so a consumer renders it from their own
+ * changelog route and hands it the releases their release pipeline published.
+ */
+export function ChangelogPage({ eyebrow, title, description, releases, kinds, filters, older, subscribe, empty, headingLevel = 'h1', className, }) {
+    const band = childLevel(headingLevel);
+    return (_jsxs("div", { "data-slot": "changelog-page", className: cn(className), children: [_jsx(Section, { "data-slot": "changelog-page-heading", children: _jsx(SectionHeading, { as: headingLevel, align: "left", eyebrow: eyebrow, title: title, description: description }) }), kinds === undefined && filters === undefined ? null : (_jsx(Section, { "data-slot": "changelog-page-filters", children: _jsxs("div", { className: "flex flex-col items-start gap-4", children: [kinds === undefined || kinds.length === 0 ? null : (_jsx("ul", { "data-slot": "changelog-page-kinds", className: "flex flex-wrap items-center gap-2", children: kinds.map((kind) => (_jsx("li", { children: _jsx(Badge, { variant: kind.state === 'on' ? 'secondary' : 'outline', "data-state": kind.state, children: kind.label }) }, kind.id))) })), filters] }) })), releases.length === 0 ? (_jsx(Section, { "data-slot": "changelog-page-empty", children: _jsx("div", { "data-slot": "changelog-page-empty-body", className: "text-muted-foreground text-pretty text-sm", children: empty }) })) : (releases.map((release) => (_jsx("div", { id: release.id, "data-slot": "changelog-page-release", children: _jsx(Changelog01, { headingLevel: band, releases: [
+                        {
+                            id: release.id,
+                            version: release.version,
+                            at: release.at,
+                            summary: release.summary,
+                            entries: release.entries.map((entry) => ({ ...entry })),
+                        },
+                    ] }) }, release.id)))), older === undefined ? null : _jsx(Section, { "data-slot": "changelog-page-older", children: older }), subscribe === undefined ? null : (_jsxs(Section, { "data-slot": "changelog-page-subscribe", children: [_jsx(SectionHeading, { as: band, align: "left", title: subscribe.title, description: subscribe.description, className: "mb-8" }), subscribe.cta] }))] }));
+}
+export default ChangelogPage;