@nanisoft/prism-ui 0.5.1 → 0.7.0

package/dist/pages/docs-shell/docs-shell.js

@@ -0,0 +1,197 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Prose } from '../../components/ui/prose';
+import { Heading, Text } from '../../components/ui/typography';
+import { cn } from '../../lib/utils';
+/**
+ * A documentation screen: a navigation rail, the document, a contents rail and
+ * the pager to the neighbouring pages.
+ *
+ * **This is the Page the other three NaniSoft sites import, and the name is
+ * theirs.** All three already read `import { DocsShell, type DocsNavEntry }
+ * from '@nanisoft/prism-ui/pages'` in their own document template, and all three
+ * map their page tree into that shape in their own `lib/to-prism-tree`. A
+ * published name cannot be cheaply changed and there is no redirect lane for item
+ * routes, so the name follows the three import lines rather than this file's
+ * shape. It was `docs-shell` in the retired line, where it was an empty
+ * `div` plus a class name that each site then had to style from scratch, and it
+ * is `docs-shell` here because that is what the three call sites already say.
+ *
+ * **A section is a label, not a control.** It carries no status, no badge, no
+ * count, no collapse and no sort, and that is the whole of its interface. The
+ * reason is specific: AlphaLens files its documentation as a pipeline, where
+ * "Unified data contract (approved)" is a stage of the work and not a topic a
+ * reader may visit in any order, and every structural affordance says the
+ * opposite. A status in the title is part of the title and stays there as words:
+ * the Page reads no parentheses, matches no vocabulary, and renders no pill
+ * beside a heading that has one. A tree is data, and a Page that parsed a
+ * consumer's data would be a Page that had opinions about it.
+ *
+ * **A group with no index is a label rather than a route.** `href` is optional
+ * on `DocsNavGroup` for exactly that, and the absence means the label. The three
+ * consumer sites all write `url: node.index?.url ?? ''` in their own adapter
+ * today, which is the same fact spelled as an empty string, and two of the three
+ * then carry a stylesheet rule that styles the resulting anchor-with-no-href
+ * back into a label. Naming the case in the type makes those two rules dead
+ * rather than load-bearing, and the type is the only place that had to change.
+ *
+ * **The pager is derived from the navigation rather than passed.** The rail
+ * already knows every page and the order a reader meets them in, and deriving the
+ * two neighbours from that plus `currentHref` removes one derivation from each
+ * of the three sites. It is derived rather than passed for a second reason: a
+ * caller who passes neighbours can pass a neighbour that is not in the tree, and
+ * this is the one arrangement where a reader would notice.
+ *
+ * **The consumer supplies two orders and the Page imposes neither.** `nav` is in
+ * the order the rail shows, and `toc` is in the order the contents rail shows.
+ * Both are read as given: nothing is sorted, deduplicated or alphabetised, and a
+ * tree whose sections are named for subject matter reads in the order its
+ * author filed it. A Page that sorted its rail would flatten the one thing the
+ * three sites disagree about and cannot both be right about.
+ *
+ * **The rail is bounded in height.** Atlas files nineteen pages and AlphaLens
+ * files twenty-seven, so the taller tree is half again as long, and an unbounded
+ * rail on a tall tree is a rail that pushes the document below the fold before
+ * the reader has read a line of it. The rail and the contents rail are each
+ * capped against the viewport and scroll inside it, so a nineteen-page tree and a
+ * twenty-seven-page tree are both a full screen and neither is a page-long
+ * sidebar.
+ *
+ * It is a Page rather than a Block because it is a whole screen and it is the
+ * screen a content pipeline targets: a route that reads one document and hands
+ * it the page tree, the outline and the current address. A Block would be the
+ * rail, and the rail's job is not separable from the screen's, because the
+ * arrangement of rail, document, contents and pager is what the three sites each
+ * wrote separately and are here written once.
+ *
+ * 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
+ * and hands it the document their pipeline produced.
+ */
+export function DocsShell({ title, description, nav, toc, currentHref, navLabel, tocLabel, pagerLabel, pagerLabels, header, footer, className, children, }) {
+    const rail = nav && nav.length > 0 ? nav : undefined;
+    const contents = toc && toc.length > 0 ? toc : undefined;
+    const neighbours = currentHref === undefined ? undefined : deriveNeighbours(nav ?? [], currentHref);
+    return (_jsxs("div", { "data-slot": "docs-shell", className: cn('mx-auto w-full max-w-6xl px-6 py-10 lg:px-8', className), children: [header, _jsxs("div", { "data-slot": "docs-shell-frame", className: cn('flex flex-col gap-8 lg:flex-row lg:gap-10', 
+                // One column for the document, and a third for whichever rails are
+                // present. The frame is sized by what the consumer passed rather than
+                // by a fixed three-column grid, so a tree with no contents rail leaves
+                // the document the width the two remaining columns divide between
+                // them.
+                contents ? 'lg:grid lg:grid-cols-[15rem_minmax(0,1fr)] xl:grid-cols-[15rem_minmax(0,1fr)_13rem]' : 'lg:grid lg:grid-cols-[15rem_minmax(0,1fr)]'), children: [rail ? (_jsx("aside", { "data-slot": "docs-rail", className: "hidden lg:col-start-1 lg:row-start-1 lg:block", children: _jsx("nav", { "aria-label": navLabel, className: "lg:sticky lg:top-20 lg:max-h-[calc(100svh-7rem)] lg:overflow-y-auto lg:pe-4", children: _jsx(NavList, { entries: rail, currentHref: currentHref, depth: 0 }) }) })) : null, _jsxs("article", { "data-slot": "docs-article", className: "flex min-w-0 flex-col gap-8", children: [title ? (_jsxs("header", { className: "flex flex-col gap-3", children: [_jsx(Heading, { as: "h1", size: "3xl", children: title }), description ? (_jsx(Text, { size: "lg", tone: "muted", className: "max-w-measure", children: description })) : null] })) : description ? (_jsx(Text, { size: "lg", tone: "muted", className: "max-w-measure", children: description })) : null, _jsx(Prose, { fullWidth: true, children: children }), neighbours ? (_jsx(Pager, { previous: neighbours.previous, next: neighbours.next, label: pagerLabel, labels: pagerLabels })) : null] }), contents ? (_jsx("aside", { "data-slot": "docs-contents", className: "hidden lg:col-start-3 lg:row-start-1 lg:block", children: _jsx("nav", { "aria-label": tocLabel, className: "lg:sticky lg:top-20 lg:max-h-[calc(100svh-7rem)] lg:overflow-y-auto", children: _jsx(NavList, { entries: contents, currentHref: currentHref, depth: 0 }) }) })) : null] }), footer] }));
+}
+/* ------------------------------------------------------------------ *
+ * The rail
+ * ------------------------------------------------------------------ */
+/**
+ * One level of the tree as a list, at whatever depth it sits.
+ *
+ * The nesting is a rule rather than a special case: the tree is the shape the
+ * navigation has, and one level of that is the whole renderer. A tree one deep
+ * and a tree seven deep are the same code with different data, which is what
+ * lets one Page carry a site that files nine pages under a heading and a site
+ * that files six sections separated by rules.
+ */
+function NavList({ entries, currentHref, depth, }) {
+    return (_jsx("ul", { "data-slot": "docs-nav-list", "data-depth": depth, className: cn('border-border flex flex-col gap-1 border-l', 
+        // One level of indent per nested group, and none at the top, so the
+        // depth reads from the rule rather than from the words.
+        depth > 0 && 'ps-3'), children: entries.map((entry, index) => (_jsx(NavNode, { entry: entry, currentHref: currentHref, depth: depth }, `${entry.type}:${index}`))) }));
+}
+/**
+ * One entry, in whichever of the three shapes it arrives.
+ *
+ * The switch is on `type` rather than on the presence of fields, so an entry
+ * that arrives malformed falls to the last arm and renders nothing rather than
+ * rendering a destination it has no address for.
+ */
+function NavNode({ entry, currentHref, depth, }) {
+    if (entry.type === 'divider') {
+        // A rule between entries. It is a label, so it is not focusable and a reader
+        // does not meet it as a destination, and the empty title renders no words
+        // above the hairline rather than a word a reader has to interpret.
+        return (_jsx("li", { "data-slot": "docs-nav-divider", className: "border-border mt-2 border-t pt-2 first:mt-0 first:border-t-0 first:pt-0", children: entry.title ? (_jsx("span", { className: "text-muted-foreground text-xs font-medium tracking-wide uppercase", children: entry.title })) : null }));
+    }
+    if (entry.type === 'group') {
+        return (_jsx("li", { "data-slot": "docs-nav-group", children: _jsxs("div", { className: "flex flex-col gap-1", children: [entry.href === undefined ? (_jsx("span", { "data-slot": "docs-nav-label", className: cn('rounded-sm text-sm font-semibold tracking-tight', containsHref(entry, currentHref) ? 'text-foreground' : 'text-muted-foreground'), children: entry.title })) : (_jsx("a", { "data-slot": "docs-nav-heading", href: entry.href, "aria-current": currentHref === entry.href ? 'page' : undefined, className: cn('hover:text-foreground rounded-sm text-sm font-semibold tracking-tight transition-colors duration-fast ease-out', under(entry.href, currentHref) ? 'text-foreground' : 'text-muted-foreground'), children: entry.title })), entry.items.length > 0 ? (_jsx(NavList, { entries: entry.items, currentHref: currentHref, depth: depth + 1 })) : null] }) }));
+    }
+    return (_jsx("li", { "data-slot": "docs-nav-page", children: _jsx("a", { "data-slot": "docs-nav-link", href: entry.href, "aria-current": currentHref === entry.href ? 'page' : undefined, className: cn('-ms-px block border-l-2 py-1 ps-3 text-sm transition-colors duration-fast ease-out', currentHref === entry.href
+                ? 'text-foreground border-primary font-medium'
+                : 'text-muted-foreground hover:text-foreground border-transparent'), children: entry.title }) }));
+}
+/**
+ * Every page the tree holds, in the order a reader meets them.
+ *
+ * A group's own index page comes before the pages under it, because that is the
+ * order the tree states and the Page does not reorder it. A group with no index
+ * contributes its children and nothing else, which is the second thing that
+ * makes an absent `href` a label rather than a route: there is no page there for
+ * the pager to reach either. A divider contributes nothing at all.
+ */
+function flatten(entries, into = []) {
+    for (const entry of entries) {
+        if (entry.type === 'page') {
+            into.push({ title: entry.title, href: entry.href });
+            continue;
+        }
+        if (entry.type === 'group') {
+            if (entry.href !== undefined)
+                into.push({ title: entry.title, href: entry.href });
+            flatten(entry.items, into);
+        }
+    }
+    return into;
+}
+/**
+ * The pages either side of `currentHref`, or nothing when it is not in the tree.
+ *
+ * It returns `undefined` rather than a pair of blanks when the address is not in
+ * the navigation, because a pager with two empty halves is a rule above nothing
+ * and a reader cannot tell it from a page that has no neighbours.
+ */
+function deriveNeighbours(entries, currentHref) {
+    const flat = flatten(entries);
+    const at = flat.findIndex((entry) => entry.href === currentHref);
+    if (at === -1)
+        return undefined;
+    return { previous: flat[at - 1], next: flat[at + 1] };
+}
+/**
+ * The two pages either side of this one, rendered as native links.
+ *
+ * Each half renders only when there is a page for it. A "previous" link on the
+ * first page is a link to the page the reader has already read, and a "next"
+ * link on the last is a promise the site cannot keep.
+ */
+function Pager({ previous, next, label, labels, }) {
+    if (!previous && !next)
+        return null;
+    return (_jsxs("nav", { "aria-label": label, "data-slot": "docs-pager", className: "border-border mt-4 flex flex-wrap items-start justify-between gap-4 border-t pt-6", children: [previous ? (_jsxs("a", { href: previous.href, className: "hover:text-foreground flex flex-col rounded-sm transition-colors duration-fast ease-out", children: [_jsx("span", { className: "text-muted-foreground text-xs font-medium tracking-wide uppercase", children: labels.previous }), _jsx("span", { className: "text-sm font-semibold", children: previous.title })] })) : (_jsx("span", {})), next ? (_jsxs("a", { href: next.href, className: "hover:text-foreground ms-auto flex flex-col rounded-sm text-right transition-colors duration-fast ease-out", children: [_jsx("span", { className: "text-muted-foreground text-xs font-medium tracking-wide uppercase", children: labels.next }), _jsx("span", { className: "text-sm font-semibold", children: next.title })] })) : null] }));
+}
+/* ------------------------------------------------------------------ *
+ * The current address
+ * ------------------------------------------------------------------ */
+/** Under a route, or at it, and never under a route that merely starts the same. */
+function under(href, currentHref) {
+    return (href !== undefined &&
+        currentHref !== undefined &&
+        (currentHref === href || currentHref.startsWith(`${href}/`)));
+}
+/**
+ * Whether the current page is inside this group.
+ *
+ * A group with a route answers for that route and everything under it. A group
+ * without one has no route to answer with, so it asks its children, which is the
+ * only way a label can still show a reader that they are inside it.
+ */
+function containsHref(group, currentHref) {
+    if (under(group.href, currentHref))
+        return true;
+    return group.items.some((entry) => {
+        if (entry.type === 'page')
+            return under(entry.href, currentHref);
+        if (entry.type === 'group')
+            return containsHref(entry, currentHref);
+        return false;
+    });
+}
+export default DocsShell;

package/dist/pages/docs-shell/index.d.ts

@@ -0,0 +1,3 @@
+export { DocsShell, default } from './docs-shell';
+export type { DocsShellProps, DocsNavEntry, DocsNavPage, DocsNavGroup, DocsNavDivider, DocsPagerLabels, } from './docs-shell';
+//# sourceMappingURL=index.d.ts.map

package/dist/pages/docs-shell/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pages/docs-shell/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACjD,YAAY,EACV,cAAc,EACd,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAA"}

package/dist/pages/docs-shell/index.js

@@ -0,0 +1 @@
+export { DocsShell, default } from './docs-shell';

package/dist/pages/index.d.ts

@@ -3,8 +3,13 @@
  *
  * A Page is a shipped, installable screen model composed of Blocks and
  * Components that receives application-owned navigation, content and data
- * (ticket 07). The v1 roster ships four Pages. Each is also importable on its
- * own subpath, `@nanisoft/prism-ui/pages/<slug>`.
+ * (ticket 07). Each is also importable on its own subpath,
+ * `@nanisoft/prism-ui/pages/<slug>`.
+ *
+ * `DocsShell` and `DocsNavEntry` keep the names the three consumer sites already
+ * import, so the name follows those import lines rather than this file's shape.
+ * A published name cannot be cheaply changed and there is no redirect lane for
+ * item routes.
  */
 export { MarketingPage } from './marketing-page';
 export type { MarketingPageProps } from './marketing-page';
@@ -14,4 +19,10 @@ export { SettingsPage } from './settings-page';
 export type { SettingsPageProps, SettingsPageTab } from './settings-page';
 export { AuthPage } from './auth-page';
 export type { AuthPageProps, AuthPageAside } from './auth-page';
+export { NotFoundPage } from './not-found-page';
+export type { NotFoundPageProps, NotFoundLink } from './not-found-page';
+export { BlogPostPage } from './blog-post-page';
+export type { BlogPostPageProps, BlogPostTag, BlogPostNeighbour, BlogPostTrailLabels } from './blog-post-page';
+export { DocsShell } from './docs-shell';
+export type { DocsShellProps, DocsNavEntry, DocsNavPage, DocsNavGroup, DocsNavDivider, DocsPagerLabels, } from './docs-shell';
 //# sourceMappingURL=index.d.ts.map

package/dist/pages/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC9G,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,YAAY,EACV,cAAc,EACd,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAA"}

package/dist/pages/index.js

@@ -3,10 +3,18 @@
  *
  * A Page is a shipped, installable screen model composed of Blocks and
  * Components that receives application-owned navigation, content and data
- * (ticket 07). The v1 roster ships four Pages. Each is also importable on its
- * own subpath, `@nanisoft/prism-ui/pages/<slug>`.
+ * (ticket 07). Each is also importable on its own subpath,
+ * `@nanisoft/prism-ui/pages/<slug>`.
+ *
+ * `DocsShell` and `DocsNavEntry` keep the names the three consumer sites already
+ * import, so the name follows those import lines rather than this file's shape.
+ * A published name cannot be cheaply changed and there is no redirect lane for
+ * item routes.
  */
 export { MarketingPage } from './marketing-page';
 export { DashboardPage } from './dashboard-page';
 export { SettingsPage } from './settings-page';
 export { AuthPage } from './auth-page';
+export { NotFoundPage } from './not-found-page';
+export { BlogPostPage } from './blog-post-page';
+export { DocsShell } from './docs-shell';

package/dist/pages/not-found-page/index.d.ts

@@ -0,0 +1,112 @@
+import type { ReactNode } from 'react';
+/**
+ * One way out of a page that was not found.
+ *
+ * A destination, and the words for it. Both are required, because a not-found
+ * page with no way out is a dead end with a message on it, and a link with no
+ * words is a shape a reader has to guess at.
+ */
+export type NotFoundLink = {
+    /** The words of the link. */
+    label: string;
+    /** Where it goes. */
+    href: string;
+    /**
+     * Opens the destination in a new browsing context, which defaults the link
+     * relationship to `noopener noreferrer`. Almost never right here: a reader who
+     * followed a broken link and is sent to a new tab has to find their way back.
+     */
+    newTab?: boolean;
+};
+/**
+ * The props a NotFoundPage takes.
+ *
+ * Every string is a prop and the Page ships none. There is no "404", no "this
+ * page does not exist", no product name and no default set of links: a not-found
+ * page that hardcoded any of them would be a page that made a claim about a
+ * product it knows nothing about, and the one page on a site that every reader
+ * and no crawler will see is the worst place to hardcode a sentence.
+ */
+export type NotFoundPageProps = {
+    /**
+     * The status code, shown as the page's own `h1`. Required, and a string rather
+     * than a number because it is displayed, not computed: a Page never decides
+     * what code it is answering.
+     */
+    code: string;
+    /**
+     * The headline under the code: the sentence that says what happened. It is the
+     * part a reader actually reads, and it is the caller's because every product
+     * says it differently - "No node here", "This page does not exist (yet)".
+     */
+    title: string;
+    /**
+     * One or two sentences under the headline, for anything a reader should know
+     * before they follow one of the links: that the URL may be mistyped, that the
+     * page is planned, that a search would find it.
+     */
+    description?: string;
+    /**
+     * The ways out, in the order a reader should see them. Put the destination
+     * most likely to help first; a not-found page that offers a homepage link
+     * before the documentation sends a reader further from what they wanted.
+     */
+    links: readonly NotFoundLink[];
+    /**
+     * The accessible name of the row of ways out. It is required, because it is a
+     * word a reader hears and a Page that ships no copy ships no reader-facing copy
+     * either. "Ways out" is the Page's own phrasing; a site that files its
+     * destinations differently names the same landmark differently.
+     */
+    linksLabel: string;
+    /**
+     * A slot for whatever else the site wants to say here: a search box, a list of
+     * recent posts, a contact address.
+     */
+    children?: ReactNode;
+    /**
+     * Layout only, exactly as on every Component. Changing a Prism-owned visual
+     * property from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * A complete not-found screen: the code, what happened, and the ways out.
+ *
+ * All four NaniSoft sites compose one, each in its own `not-found` route, and
+ * three of them are the same six lines with a different product name on it: a
+ * display title carrying the code, one muted sentence, and two or three links.
+ * The fourth wrote the same thing in its own markup. Four hand-written screens
+ * for one shape.
+ *
+ * It is a Page rather than a Block because it is a whole screen: it owns the
+ * document's `h1`, it is what a router renders when a route does not resolve, and
+ * it composes `Section`, `Heading`, `Text`, `Prose` and `CtaLink` into the one
+ * arrangement of them that answers "this is not here". A Block would be a band
+ * of that arrangement, and the band's job is not separable from the screen's:
+ * there is one correct page here and it is short.
+ *
+ * **The code is the `h1` and the sentence is not.** A not-found page whose
+ * `h1` is "Page not found" gives a search engine and a screen reader nothing
+ * distinct to index, and the code is the one string on the page that is the same
+ * for every broken URL. The code takes the display step and the sentence takes
+ * the muted one, which is the reverse of what a reader sees first and the right
+ * way round for anything that reads the outline.
+ *
+ * The links are `CtaLink`, so each one is a native anchor with a destination a
+ * browser can show, copy and open in a new tab. A not-found page is the one place
+ * on a site where a reader most wants to see where a link goes before following
+ * it, because they have just followed one that went nowhere.
+ *
+ * The page carries no `noindex` and no `robots` directive, because this is a
+ * component and not a route: what a not-found response is indexed as is the
+ * consumer's server's decision, and a Page that declared it would be a Page
+ * making a claim about a deployment it cannot see.
+ *
+ * It is a server Component. It fetches nothing, it holds no state and it imports
+ * no router, which is what lets a consumer render it from whichever not-found
+ * route their framework names.
+ */
+export declare function NotFoundPage({ code, title, description, links, linksLabel, children, className, }: NotFoundPageProps): import("react").JSX.Element;
+export default NotFoundPage;
+//# sourceMappingURL=index.d.ts.map

package/dist/pages/not-found-page/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pages/not-found-page/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAOtC;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;IAC9B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,KAAK,EACL,WAAW,EACX,KAAK,EACL,UAAU,EACV,QAAQ,EACR,SAAS,GACV,EAAE,iBAAiB,+BA+BnB;AAED,eAAe,YAAY,CAAA"}

package/dist/pages/not-found-page/index.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CtaLink } from '../../components/ui/cta-link';
+import { Heading, Text } from '../../components/ui/typography';
+import { Prose } from '../../components/ui/prose';
+import { Section } from '../../components/ui/section';
+/**
+ * A complete not-found screen: the code, what happened, and the ways out.
+ *
+ * All four NaniSoft sites compose one, each in its own `not-found` route, and
+ * three of them are the same six lines with a different product name on it: a
+ * display title carrying the code, one muted sentence, and two or three links.
+ * The fourth wrote the same thing in its own markup. Four hand-written screens
+ * for one shape.
+ *
+ * It is a Page rather than a Block because it is a whole screen: it owns the
+ * document's `h1`, it is what a router renders when a route does not resolve, and
+ * it composes `Section`, `Heading`, `Text`, `Prose` and `CtaLink` into the one
+ * arrangement of them that answers "this is not here". A Block would be a band
+ * of that arrangement, and the band's job is not separable from the screen's:
+ * there is one correct page here and it is short.
+ *
+ * **The code is the `h1` and the sentence is not.** A not-found page whose
+ * `h1` is "Page not found" gives a search engine and a screen reader nothing
+ * distinct to index, and the code is the one string on the page that is the same
+ * for every broken URL. The code takes the display step and the sentence takes
+ * the muted one, which is the reverse of what a reader sees first and the right
+ * way round for anything that reads the outline.
+ *
+ * The links are `CtaLink`, so each one is a native anchor with a destination a
+ * browser can show, copy and open in a new tab. A not-found page is the one place
+ * on a site where a reader most wants to see where a link goes before following
+ * it, because they have just followed one that went nowhere.
+ *
+ * The page carries no `noindex` and no `robots` directive, because this is a
+ * component and not a route: what a not-found response is indexed as is the
+ * consumer's server's decision, and a Page that declared it would be a Page
+ * making a claim about a deployment it cannot see.
+ *
+ * It is a server Component. It fetches nothing, it holds no state and it imports
+ * no router, which is what lets a consumer render it from whichever not-found
+ * route their framework names.
+ */
+export function NotFoundPage({ code, title, description, links, linksLabel, children, className, }) {
+    return (_jsx(Section, { className: className, children: _jsxs("div", { className: "flex flex-col items-start gap-6", children: [_jsx(Heading, { as: "h1", size: "4xl", className: "text-muted-foreground font-mono", children: code }), _jsxs("div", { className: "flex flex-col gap-3", children: [_jsx(Heading, { as: "h2", size: "2xl", children: title }), description ? _jsx(Text, { size: "lg", children: description }) : null] }), links.length > 0 ? (_jsx("nav", { "aria-label": linksLabel, className: "flex flex-wrap items-center gap-3", children: links.map((link, index) => (_jsx(CtaLink, { href: link.href, newTab: link.newTab, variant: index === 0 ? 'default' : 'outline', children: link.label }, link.href))) })) : null, children ? _jsx(Prose, { className: "mt-2", children: children }) : null] }) }));
+}
+export default NotFoundPage;

package/dist/provider/provider.d.ts

@@ -7,6 +7,11 @@
  * the same two markup attributes the declarative form uses. There is no
  * override, merge, token, className or style prop: the provider's only outputs
  * are the document-element attributes and context (ticket 07).
+ *
+ * It resolves through `resolveTheme`, the one rule the boot script also
+ * implements, and it never writes `THEME_ORIGIN_ATTRIBUTE`: the script is that
+ * attribute's only writer, and two writers would turn a record of the origin
+ * into a race.
  */
 import { type ReactNode } from 'react';
 import { type Mode, type PackId } from '../theming';

package/dist/provider/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/provider/provider.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAA;AAEd,OAAO,EAML,KAAK,IAAI,EACT,KAAK,MAAM,EACZ,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB,CAAA;AAID,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,sCAAsC;IACtC,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,CAAA;AAwBD,wBAAgB,aAAa,CAAC,EAC5B,WAAuB,EACvB,WAAqB,EACrB,UAAgC,EAChC,QAAQ,GACT,EAAE,kBAAkB,+BA8CpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAM1C"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/provider/provider.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAA;AAEd,OAAO,EAML,KAAK,IAAI,EACT,KAAK,MAAM,EAEZ,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB,CAAA;AAID,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,sCAAsC;IACtC,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,CAAA;AAyCD,wBAAgB,aAAa,CAAC,EAC5B,WAAuB,EACvB,WAAqB,EACrB,UAAgC,EAChC,QAAQ,GACT,EAAE,kBAAkB,+BAuHpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAM1C"}