@plitzi/sdk-elements 0.38.6 → 0.38.7

package/CHANGELOG.md

@@ -1,5 +1,210 @@
 # @plitzi/sdk-elements
 
+## 0.38.7
+
+### Patch Changes
+
+- c7bbc2b: ## A server project's `src/main.ts` is a few lines
+
+  - **`serveProject` from `@plitzi/sdk-server/project`**: the generated `src/main.ts` hands the space, its actions and
+    its options to the server, and the rest comes with the package — the port, the plugins of `src/plugins` and
+    `vendor/plugins`, the functions and runtime, `public/`, `src/data/`, the `kv` in `state/kv.json`, `/health`,
+    `tmp/dev-server.json` and the reloads while developing. A fix there arrives with `npm update`, not `plitzi upgrade`.
+  - **No more `tmp/space.json` while developing**: a saved space is authored again in its own process and handed to the
+    server over IPC (`plitzi/author.ts --ipc`, in place of `--out`); the server swaps it in memory and the open pages
+    reload, and a refused space keeps the last one that authored. `plitzi doctor` reports a leftover `tmp/space.json`.
+  - **`projectAuthoring()` in `@plitzi/sdk-authoring/node`**: what a project's space is checked against — its plugins'
+    declarations, its built plugins, its data files — once, for the server and `npm run author` alike. Neither it nor
+    `serveProject` takes a root: it is the working directory, where every script runs (`projectAuthoringAt(root)` for a
+    tool working on another folder).
+  - **`authorProjectSpace` and `projectSpace()` in `@plitzi/sdk-authoring/node`**: the project's space read from
+    `src/space/index.ts` — `dist/space/index.js` when the server runs built — once its root and layout are checked, and
+    authored. `src/main.ts` is `serveProject({ space: authorProjectSpace, actions, connectors, serverOptions })`, with no
+    import of the space; `plitzi/author.ts`, the visual tests and the CLI's checks read it the same way. A module that
+    exports no `space` is refused saying what to export (`ProjectSpaceError`).
+  - **`.env` lives at the root and Node reads it** as each script starts (`--env-file-if-exists=.env`; `start:dev`
+    preloads `@plitzi/sdk-server/env`, since a watched process would restart on every change beside the file). Settings
+    read at the top level of `src/config/serverOptions.ts` or the actions are set. Every project gets `.env` and
+    `.env.example`; `plitzi upgrade` removes the old `src/env.ts`.
+  - **One check of a project's layout** (`@plitzi/sdk-shared/project/layout`): a plugin folder with no entry, a
+    JavaScript entry, `src/plugin/` for `src/plugins/`, a `.env` inside `src/`, a space exported by default, a broken
+    `vendor/` plugin… The server refuses to boot listing every error with its fix, `npm run author` and the CLI's checks
+    refuse with the same words, `plitzi doctor` lists them under `layout` and `--fix` makes the ones with a single fix,
+    and `plitzi lint` points at doctor. A plugin folder added broken while developing is reported in the terminal
+    instead of failing in esbuild. Plugins may start at `index.tsx`.
+  - **`createJsonAdapters` serves documents held in memory**: `offlineData` may be a function returning them, not only a
+    path.
+  - **One source for a project's layout**, `@plitzi/sdk-shared/project/paths`; `src/config/serverOptions.ts` is typed
+    `ProjectServerOptions`. `plitzi upgrade files --write` brings an existing project's `main.ts` and `author.ts` up.
+  - **`npm run build` no longer fails on a plugin's stylesheet**: `tsconfig.build.json` includes `plitzi/assets.d.ts`,
+    which a space importing a plugin's declaration reaches through its component.
+
+  ## A write refreshes what shows it
+  - **Writes now refresh server-driven providers.** `runServerAction`, `webHook`, `writeRecord` and the
+    `invalidateQueries` step reach `runtime: 'server'` api containers by id, by `query` URL, or all of them, just as
+    they reach cached browser requests. Before, they reached only the browser's query cache, so a saved write left the
+    page showing the old value until a reload. Hidden providers refresh when they are shown.
+  - **A refresh because something changed asks around every cache.** `performQuery`, writes and invalidations send
+    `Cache-Control: no-cache`; `/_rsc` resolves such a request again instead of serving its cached slice, and keeps the
+    new answer. A `refreshSeconds` timer and a "load more" page still go through the caches.
+  - **`refreshRsc`'s fourth argument is an options object**, `{ location?, fresh? }`.
+
+  ## A space's functions read its data
+  - **`ctx.data('products.json')`** reads one file of the space's data (a project's `src/data/`), parsed and read-only,
+    as of the run's version. Plugins' functions are refused it.
+  - **Self-hosted servers read `dataDir` through the same lookup as the platform**, so `/data/<file>` providers and
+    `ctx.data` read the same files; `plitzi functions dev` reads `src/data`. `/data/../x.json` is now the provider's
+    error state instead of falling through to `publicDir`.
+  - **Importing a file outside `functions/` names the boundary and the fix**: read the space's data with
+    `ctx.data('<file>')`.
+
+  ## Signing in on a self-hosted server
+  - **`createServer({ auth })` tells the pages it renders where to sign in** (`server.auth`: provider, endpoints and
+    the session hint cookie), so a space signs in with no auth settings declared. Settings a space does declare still
+    win, and a space that names another provider ignores the server's description. New `pageAuth` server option, for a
+    deployment whose `/auth` flows are served by another host.
+  - **A page with no auth provider no longer offers `auth.login` / `auth.logout`**, and a sign-in that cannot work says
+    why in the console (`[plitzi] auth.login: …`) instead of failing silently. What a visitor keeps there
+    (`keepState`, `paintedState`) is the browser's, as on any space without accounts: what was kept as a guest's on such
+    a page before is let go once, on the first visit after the upgrade.
+  - **Renewal verifies the refresh token itself.** `findByRefreshToken` no longer has to report `refreshExpiresAt`; when
+    it does, it overrides the token's own expiry.
+  - **New authoring reference `auth.md`**: providers, `authLogin` and its result, `authLogout`, `{{ auth.* }}`,
+    `accessLevel`, visitor roles, action `access` and `ctx.user`.
+
+  ## Flows
+  - **Authoring refuses a `when` that asks a step for a key it never publishes** (`condition-field-unpublished`).
+    `whenSucceeded` / `whenFailed` after `authLogin` always ran the failure branch: they read a server action's
+    `status`. The message names what the step publishes and suggests testing `signedIn.ok` with `when`.
+  - **`explain` lists what a step publishes** (`Reads:`) and finds the auth steps by their builders (`authLogin`,
+    `authLogout`, `authRefreshDetails`). `authLogin({ username, password })` no longer needs `mode`.
+
+  ## Elements
+  - **Images no longer default to a 140×140 square**: they are 140px wide and as tall as their ratio, so `width` or
+    `aspect-ratio` on a class just works. `object-fit` shows in the builder too.
+  - **`formControl` with `subType: 'switch'` renders an on/off switch** (`role="switch"`) — it rendered only its label.
+    Checkboxes and switches show a `true` default or binding as ticked.
+  - **The theme toggle drops the native button look**, and the **`current` style state covers the chosen item of any
+    set**: the link to the page shown, a pressed toggle, a selected tab. The exported `CURRENT_PAGE_SELECTOR` is now
+    `CURRENT_SELECTOR`.
+  - **Element defaults in the style inspector and the MCP catalogue match what the SDK renders**, held by a test. The
+    dialog's `bodyContainer` and `headerCloseButton` slots now reach the page; pagination lays out as declared.
+  - **Markdown takes a class for each part of the document** through its own slot (`heading`, `paragraph`, `link`,
+    `list`, `listItem`, `quote`, `code`, `codeBlock`, `image`, `table`, `anchor`), and `headingLinks: false` drops the
+    link each heading offers to itself while keeping its id, so `/page#anchor` links still work. Its description spells
+    out the HTML it outputs.
+  - **Tabs show every trigger.** The SDK hid every inactive tab item, the header's included, so a set of tabs showed
+    one tab and no way to the others; only the body's panels take turns now.
+  - **A link that names a query is current only on that query**: of `/?window=6h` and `/?window=24h`, the one shown
+    carries `aria-current` — with the path alone, every one of them did. A link with no query is still current on its
+    page whatever the query.
+
+  ## The style language says what `customCss` used to
+  - **Pseudo-elements on a class**: `pseudos: { after: { css: { content: '"→"' }, states: { hover: { … } } } }` —
+    `before`, `after`, `marker`, `placeholder`, `first-letter`, `first-line`, `selection`, each in the class's states and
+    variants. Authoring refuses what draws nothing: a `before`/`after` with no `content`, a `content` without its quotes,
+    a property the browser drops on that pseudo-element.
+  - **Conditions on a class**: `conditions: { 'motion-reduce': { … }, 'container card (max-width: 30rem)': { … } }` —
+    reduced or allowed motion, and container widths, each with its states and pseudo-elements.
+  - **The space's `keyframes`**, validated and written at the top of `customCss`; an `animation-name` no keyframes declare
+    is warned (`animation-name-unknown`).
+  - **New states**: `expanded` (`aria-expanded`), `first`, `last`, `odd`, `even`; the tab panel on show is `current`, and
+    the theme toggle's icon of the scheme in use is `current` on its `icon` slot.
+  - **`ancestors['>']`** is the parent, whatever it wears — a closed component's part reacting to the element around it.
+  - The builder's style inspector, the MCP's definition ops (`pseudos`, `conditions`, and variants with their states) and
+    the export to code read and write all of it; an MCP `patchDefinition` no longer drops what it did not name. Rules in
+    `customCss` a class can hold now — `.link::after`, one under `@media (prefers-reduced-motion: reduce)`, `.row:first-child`,
+    `.row:nth-child(even)`, `.toggle[aria-expanded='true']` — are folded into the class on export and suggested by
+    `custom-css-class`.
+
+  ## Elements take a class for each part
+  - **`formControl`**: `field` (the `<input>` itself), `icon` (the show-password button) and `requiredMark` slots; a switch's
+    knob reads in dark mode and takes `--plitzi-switch-thumb`, `--plitzi-switch-thumb-checked`, `--plitzi-switch-thumb-shadow`.
+  - **`pagination`**: `previous`, `page` (the one shown is its `current` state), `next`, `loadMore`.
+  - **`richText`** and **`markdown`**: a slot per part — `heading` and `heading1`…`heading6`, `strong`, `emphasis`,
+    `divider`, `tableHead`, `tableRow`, `tableHeaderCell`, `tableCell`, and the code block's frame, header, language and
+    copy button. Both heading slots dress one `<h3>`, so `heading-level-overridden` warns when they set the same property
+    and the stylesheet's order makes the general one win. A document is drawn by the SDK's own renderer
+    (`MarkdownDocument` in `@plitzi/sdk-elements`) — plitzi-ui's `Markdown` keeps GitHub's stylesheet for a library's
+    consumers — and reads as a document unstyled: headings, lists, code, tables and quotes get their type from the SDK's
+    base layer, at no weight (`:where()`), so a class on a part's slot replaces what it sets property by property. A
+    `richText` body reads the same.
+  - `custom-css-slot` suggests the slot for a `customCss` rule on a part's SDK class — only where a class on the slot can
+    say the rest of the selector (a state, a pseudo-element); `element-slot-unknown` warns of a slot an element does not
+    have.
+
+  ## Links, refreshes and toasts
+  - **`current: 'section'` on a link** keeps it current on its page and every page under its path (`aria-current="true"`
+    there), styled by the `current` state — no `activeOn` binding for a section.
+  - **A refresh asks only about elements the page shown holds**: a provider on the page being left no longer sends a
+    `/_rsc` about the new address.
+  - **The toasts' parts are `notifications` fields**: `minHeight`, `fontWeight`, `lineHeight`, `iconSize`, `iconGap`,
+    `closeColor`, `closeOpacity`, `progressHeight`.
+  - **A page asked for with its space's token hydrates its own space.** On a host serving many spaces
+    (`?access-token=`), the space document fetched beside the page went without the token, so the host's own space
+    answered it and the browser hydrated another space's document over the page — a hydration error, and its tree
+    rebuilt. The document's address now carries the token the page was asked for with.
+  - **The SDK's stylesheet carries the space's variables from the server's HTML.** It read them from what a provider
+    below it publishes while the page renders, which the server had not done yet when it wrote the sheet; it now
+    resolves them from the document itself (`useResolvedVariables` of `@plitzi/sdk-shared/dataSource/hooks`), the same
+    on both sides.
+  - **A realtime message the pub/sub cannot deliver is answered, not fatal.** A publish that Redis refuses — a timeout under
+    load — is answered `503` with `reason: 'unavailable'`, by the `POST` and in the WebSocket's `ack` alike; a connect,
+    a disconnect or a revoke that fails is logged, on either transport. Each used to reject with nobody waiting, and the server's `unhandledRejection` handler
+    shut the whole process down.
+
+  ## Reporting to Plitzi
+  - **`plitzi feedback`** starts a report of what broke, misled or cost time: it writes the page the report is laid out
+    in (`tmp/feedback/`) with the installed versions, the project and what `doctor` finds already in it, and tells the
+    agent how to fill it — each finding reproduced first, with evidence, impact, workaround and fix, no secrets — and to
+    publish it as an artifact whose link the developer sends. `--previous <url>` continues an earlier report.
+
+  ## Pages that load on every browser
+  - **The import map comes before anything that loads a module**, in the page server's HTML, a published site's
+    (`index.hbs` on the platform), the SDK's and the builder's. React's `modulepreload` links came first, and a browser
+    that had fetched a module already — Chrome before 133 — ignored the map: every bare `import "react"` failed
+    ("Failed to resolve module specifier") and the page never hydrated.
+
+  ## The dev tools
+  - **A page loads the React its dev tools need.** The development build only while the visitor has the dev tools on
+    (shift+F12, within what the deployment allows); turned off, the next load is a production page, React included. It
+    followed the authorization alone, so a space that allowed debugging always shipped development React.
+
+  ## check and lint
+  - **`plitzi check`, `push`, `lint` and `fix` hold the space to what `npm run author` and the server do**: its data
+    files too, so `push` no longer sends a space whose browser provider reads `src/data/` (`server-data-in-browser`).
+  - **`plitzi check` lists each list's rows as drawn and as held in its source** (`feed 4 of 8 rows`,
+    `hits not rendered (16 in its source)`). In `--json`, `lists` is now `{ id: { rendered, source } }`.
+  - **`plitzi check` no longer reports bindings inside a container the page isn't showing**, nor text "in the colour
+    behind it" because of a bar painted over it or a pane that clips it.
+  - **`window.__plitzi.sources()` no longer turns a shared array into `'[…]'`**, and a list row no longer replaces its
+    list's `items`.
+  - **`plitzi lint` says authoring suggestions are quieted with `quiet` on the element**, and reports a
+    `plitzi-lint-disable` comment that names one (`disable-names-suggestion`).
+  - **`plitzi check` says when a page sent the browser elsewhere** (a page for signed-in visitors, to the sign-in) instead
+    of reporting every element missing, and `--as <username>` signs in first through the server's `/auth` routes, the
+    password from `PLITZI_CHECK_PASSWORD`.
+  - **`plitzi upgrade` never replaces @plitzi packages installed locally** — a tarball, a link, a portal, an override: it
+    leaves them and the install, and says which and the command that would install the registry's.
+  - **`plitzi explain` covers every code**: authoring's, `plitzi lint`'s and the project layout's.
+  - **Authoring reads the global sources' fields**: `auth.authenticated` in a condition is refused with "did you mean
+    `isAuthenticated`?" (`global-field-unknown`), and `invalidateElements` must name providers that exist
+    (`element-ids-target`). A template's reads of `computed`, `flags` and the global sources come off the parsed
+    template: a string inside it (`'https://auth.acme.com'`) is no longer read as `auth.acme`.
+  - **`custom-css-notifications` no longer reads the rules `notifications` itself writes** as toasts dressed by hand.
+  - **A refused space or layout is a report, not a stack**: the server's entry point imports the space once the layout is
+    checked, and `npm start` and `npm run author` print every problem and exit with 1.
+  - **New authoring suggestion `class-overrides-class`**: one class's shorthand (`padding`) silently erases a longhand
+    (`padding-top`) another class on the same element writes out.
+
+- Updated dependencies [c7bbc2b]
+  - @plitzi/sdk-auth@0.38.7
+  - @plitzi/sdk-event-bridge@0.38.7
+  - @plitzi/sdk-interactions@0.38.7
+  - @plitzi/sdk-navigation@0.38.7
+  - @plitzi/sdk-schema@0.38.7
+  - @plitzi/sdk-shared@0.38.7
+
 ## 0.38.6
 
 ### Patch Changes

package/dist/Element/hooks/useRscData.d.ts

@@ -16,7 +16,7 @@ declare const useRscData: <T>() => {
     isServerElement: boolean;
     /** A refresh asking about this element — or about the whole payload of this page — is in flight. */
     refreshing: boolean;
-    refresh: (ids?: string[], params?: Record<string, string>) => Promise<void>;
+    refresh: (ids?: string[], params?: Record<string, string>, { fresh }?: Pick<import('@plitzi/sdk-shared').RscRefreshOptions, "fresh">) => Promise<void>;
     /** Stops this element's refresh in flight, here and on the server; what it shows stays. */
     cancel: () => void;
 };

package/dist/components/MarkdownDocument/MarkdownDocument.d.ts

@@ -0,0 +1,32 @@
+import { MarkdownClassNames } from './helpers/markdownParts';
+import { HeadingAnchor } from './helpers/rehypeHeadingAnchors';
+export type MarkdownDocumentProps = {
+    className?: string;
+    children?: string;
+    wrapLines?: boolean;
+    showLineNumbers?: boolean;
+    /**
+     * The id each heading carries, so `#id` lands on it — asked once per heading, in order, with the ids already given.
+     * Without it a heading carries none and offers no link to itself.
+     */
+    headingAnchor?: HeadingAnchor;
+    /**
+     * Whether a heading that has an id offers a link to itself (`a.anchor`) before its words. `false` keeps the ids — a
+     * `#id` still lands on the heading — and leaves the link out.
+     */
+    headingLinks?: boolean;
+    /**
+     * A class for each part of the output, beside the one it already has: `{ heading: 'doc-heading', link: 'doc-link' }`
+     * — the parts are `MARKDOWN_PARTS`. The output carries no stylesheet of its own beyond the code blocks' highlighting:
+     * the SDK's base layer gives an undressed document its type (`_document.scss`), below every class.
+     * Keep it the same object from one render to the next: a new one rebuilds every tag of the document.
+     */
+    classNames?: MarkdownClassNames;
+};
+/**
+ * A Markdown source (GitHub-flavoured) as HTML, inside a `div.markdown`, each part of it with the class the consumer
+ * gives it — the SDK's own copy of plitzi-ui's `Markdown`, which ships GitHub's stylesheet for a library's consumers:
+ * here the space dresses every part, and a stylesheet of its own would win over what the space writes.
+ */
+declare const MarkdownDocument: ({ className, children, wrapLines, showLineNumbers, headingAnchor, headingLinks, classNames }: MarkdownDocumentProps) => import('react').JSX.Element;
+export default MarkdownDocument;

package/dist/components/MarkdownDocument/MarkdownDocument.mjs

@@ -0,0 +1,32 @@
+import { markdownComponents as e } from "./helpers/markdownComponents.mjs";
+import { rehypeHeadingAnchors as t } from "./helpers/rehypeHeadingAnchors.mjs";
+import { useMemo as n } from "react";
+import { jsx as r } from "react/jsx-runtime";
+import i from "clsx";
+import a from "react-markdown";
+import o from "remark-gfm";
+//#region src/components/MarkdownDocument/MarkdownDocument.tsx
+var s = {}, c = [o], l = ({ className: o, children: l = "", wrapLines: u = !0, showLineNumbers: d = !0, headingAnchor: f, headingLinks: p = !0, classNames: m = s }) => {
+	let h = n(() => f ? [t(f)] : [], [f]), g = n(() => e({
+		classNames: m,
+		headingLinks: p,
+		wrapLines: u,
+		showLineNumbers: d
+	}), [
+		m,
+		p,
+		u,
+		d
+	]);
+	return /* @__PURE__ */ r("div", {
+		className: i("markdown", o),
+		children: /* @__PURE__ */ r(a, {
+			remarkPlugins: c,
+			rehypePlugins: h,
+			components: g,
+			children: l
+		})
+	});
+};
+//#endregion
+export { l as default };

package/dist/components/MarkdownDocument/components/CodeBlock/CodeBlock.d.ts

@@ -0,0 +1,14 @@
+import { MarkdownClassNames } from '../../helpers/markdownParts';
+import { ReactNode } from 'react';
+export type CodeBlockProps = {
+    /** The language the block is written in, as its fence named it. */
+    language?: string;
+    /** The block's text, as it is copied. */
+    code: string;
+    /** The classes of the frame's parts — `codeBlockFrame`, `codeBlockHeader`, `codeBlockLanguage`, `codeBlockCopy`. */
+    classNames: MarkdownClassNames;
+    children?: ReactNode;
+};
+/** A fenced block with what it is written in and a way to take it: a header over the code itself. */
+declare const CodeBlock: ({ language, code, classNames, children }: CodeBlockProps) => import('react').JSX.Element;
+export default CodeBlock;

package/dist/components/MarkdownDocument/components/CodeBlock/CodeBlock.mjs

@@ -0,0 +1,34 @@
+import { useCallback as e, useEffect as t, useState as n } from "react";
+import { jsx as r, jsxs as i } from "react/jsx-runtime";
+import a from "clsx";
+//#region src/components/MarkdownDocument/components/CodeBlock/CodeBlock.tsx
+var o = 2e3, s = ({ language: s, code: c, classNames: l, children: u }) => {
+	let [d, f] = n(!1);
+	t(() => {
+		if (!d) return;
+		let e = setTimeout(() => f(!1), o);
+		return () => clearTimeout(e);
+	}, [d]);
+	let p = e(() => {
+		navigator.clipboard.writeText(c).then(() => f(!0));
+	}, [c]);
+	return /* @__PURE__ */ i("div", {
+		className: a("markdown-code", l.codeBlockFrame),
+		"data-language": s,
+		children: [/* @__PURE__ */ i("div", {
+			className: a("markdown-code-header", l.codeBlockHeader),
+			children: [/* @__PURE__ */ r("span", {
+				className: a("markdown-code-language", l.codeBlockLanguage),
+				children: s ?? "text"
+			}), /* @__PURE__ */ r("button", {
+				type: "button",
+				className: a("markdown-code-copy", l.codeBlockCopy),
+				onClick: p,
+				"aria-live": "polite",
+				children: d ? "Copied" : "Copy"
+			})]
+		}), u]
+	});
+};
+//#endregion
+export { s as default };

package/dist/components/MarkdownDocument/components/CodeBlock/index.d.ts

@@ -0,0 +1,3 @@
+import { default as CodeBlock } from './CodeBlock';
+export * from './CodeBlock';
+export default CodeBlock;

package/dist/components/MarkdownDocument/components/CodeBlock/index.mjs

@@ -0,0 +1,5 @@
+import e from "./CodeBlock.mjs";
+//#region src/components/MarkdownDocument/components/CodeBlock/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/MarkdownDocument/helpers/hastText.d.ts

@@ -0,0 +1,10 @@
+/** The part of a syntax-tree node this package reads: its words, and the nodes under it. */
+export type HastNode = {
+    type: string;
+    tagName?: string;
+    value?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+};
+/** The words under a node, as a reader sees them: text only — a picture's alt and raw HTML are not text. */
+export declare const hastText: (node: HastNode) => string;

package/dist/components/MarkdownDocument/helpers/hastText.mjs

@@ -0,0 +1,4 @@
+//#region src/components/MarkdownDocument/helpers/hastText.ts
+var e = (t) => t.type === "text" ? t.value ?? "" : (t.children ?? []).map(e).join("");
+//#endregion
+export { e as hastText };

package/dist/components/MarkdownDocument/helpers/markdownComponents.d.ts

@@ -0,0 +1,10 @@
+import { MarkdownClassNames } from './markdownParts';
+import { Components } from 'react-markdown';
+export type MarkdownComponentsOptions = {
+    classNames: MarkdownClassNames;
+    headingLinks: boolean;
+    wrapLines: boolean;
+    showLineNumbers: boolean;
+};
+/** What each tag of a Markdown source is written as: its parts' classes, the headings' links and the code blocks. */
+export declare const markdownComponents: (options: MarkdownComponentsOptions) => Components;

package/dist/components/MarkdownDocument/helpers/markdownComponents.mjs

@@ -0,0 +1,89 @@
+import { hastText as e } from "./hastText.mjs";
+import { SyntaxHighlighter as t } from "./syntaxHighlighter.mjs";
+import n from "../components/CodeBlock/index.mjs";
+import { createElement as r } from "react";
+import { omit as i } from "@plitzi/plitzi-ui/helpers";
+import { jsx as a, jsxs as o } from "react/jsx-runtime";
+import s from "clsx";
+import c from "react-syntax-highlighter/dist/esm/styles/prism/vsc-dark-plus";
+//#region src/components/MarkdownDocument/helpers/markdownComponents.tsx
+var l = {
+	h1: "heading1",
+	h2: "heading2",
+	h3: "heading3",
+	h4: "heading4",
+	h5: "heading5",
+	h6: "heading6"
+}, u = /language-(\w+)/, d = (e, t) => ({ className: n, ...a }) => r(e, {
+	...i(a, ["node"]),
+	className: s(n, t) || void 0
+}), f = (t, { classNames: n, headingLinks: r }) => ({ children: i, node: c, className: u, ...d }) => /* @__PURE__ */ o(t, {
+	...d,
+	className: s(u, n.heading, n[l[t]]) || void 0,
+	children: [r && d.id && /* @__PURE__ */ a("a", {
+		className: s("anchor", n.anchor),
+		href: `#${d.id}`,
+		"aria-label": `Link to “${c ? e(c) : d.id}”`,
+		children: /* @__PURE__ */ a("span", {
+			className: "octicon octicon-link",
+			"aria-hidden": "true"
+		})
+	}), i]
+}), p = (r) => {
+	let { classNames: o, wrapLines: l, showLineNumbers: p } = r;
+	return {
+		h1: f("h1", r),
+		h2: f("h2", r),
+		h3: f("h3", r),
+		h4: f("h4", r),
+		h5: f("h5", r),
+		h6: f("h6", r),
+		p: d("p", o.paragraph),
+		a: d("a", o.link),
+		strong: d("strong", o.strong),
+		em: d("em", o.emphasis),
+		ul: d("ul", o.list),
+		ol: d("ol", o.list),
+		li: d("li", o.listItem),
+		blockquote: d("blockquote", o.quote),
+		hr: d("hr", o.divider),
+		img: d("img", o.image),
+		table: d("table", o.table),
+		thead: d("thead", o.tableHead),
+		tr: d("tr", o.tableRow),
+		th: d("th", o.tableHeaderCell),
+		td: d("td", o.tableCell),
+		pre: ({ children: t, node: r, className: i, ...c }) => {
+			let l = /* @__PURE__ */ a("pre", {
+				...c,
+				className: s(i, o.codeBlock) || void 0,
+				children: t
+			}), d = r?.children.find((e) => e.type === "element" && e.tagName === "code");
+			if (!d || d.type !== "element") return l;
+			let f = d.properties.className, p = Array.isArray(f) ? f.map(String).map((e) => u.exec(e)?.[1]).find(Boolean) : void 0;
+			return /* @__PURE__ */ a(n, {
+				language: p,
+				code: e(d).replace(/\n$/, ""),
+				classNames: o,
+				children: l
+			});
+		},
+		code: ({ children: e, className: n, ...r }) => {
+			let d = i(r, ["node"]), f = u.exec(n || "");
+			return f ? /* @__PURE__ */ a(t, {
+				PreTag: "div",
+				language: f[1],
+				style: c,
+				wrapLines: l,
+				showLineNumbers: p,
+				children: typeof e == "string" ? e.replace(/\n$/, "") : ""
+			}) : /* @__PURE__ */ a("code", {
+				...d,
+				className: s(n, o.code) || void 0,
+				children: e
+			});
+		}
+	};
+};
+//#endregion
+export { p as markdownComponents };

package/dist/components/MarkdownDocument/helpers/markdownParts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The parts of the HTML a Markdown source is written as, each of which can carry a class of the consumer's own.
+ *
+ * - `heading` is every heading, `h1`–`h6`; `heading1`…`heading6` is the one of that level, beside it.
+ * - `paragraph` (`p`), `link` (`a`), `strong` (`strong`), `emphasis` (`em`), `list` (`ul`/`ol`), `listItem` (`li`),
+ *   `quote` (`blockquote`), `divider` (`hr`), `image` (`img`).
+ * - `code` is inline `code`; `codeBlock` the `pre` of a fenced block, inside its frame (`div.markdown-code`,
+ *   `codeBlockFrame`) under a header (`div.markdown-code-header`, `codeBlockHeader`) that holds its language
+ *   (`span.markdown-code-language`, `codeBlockLanguage`) and its copy button (`button.markdown-code-copy`,
+ *   `codeBlockCopy`).
+ * - `table`, `tableHead` (`thead`), `tableRow` (`tr`), `tableHeaderCell` (`th`), `tableCell` (`td`).
+ * - `anchor` is the link a heading offers to itself.
+ */
+export declare const MARKDOWN_PARTS: readonly ["heading", "heading1", "heading2", "heading3", "heading4", "heading5", "heading6", "paragraph", "link", "strong", "emphasis", "list", "listItem", "quote", "divider", "code", "codeBlock", "codeBlockFrame", "codeBlockHeader", "codeBlockLanguage", "codeBlockCopy", "image", "table", "tableHead", "tableRow", "tableHeaderCell", "tableCell", "anchor"];
+export type MarkdownPart = (typeof MARKDOWN_PARTS)[number];
+export type MarkdownClassNames = Partial<Record<MarkdownPart, string>>;

package/dist/components/MarkdownDocument/helpers/markdownParts.mjs

@@ -0,0 +1,4 @@
+//#region src/components/MarkdownDocument/helpers/markdownParts.ts
+var e = /* @__PURE__ */ "heading.heading1.heading2.heading3.heading4.heading5.heading6.paragraph.link.strong.emphasis.list.listItem.quote.divider.code.codeBlock.codeBlockFrame.codeBlockHeader.codeBlockLanguage.codeBlockCopy.image.table.tableHead.tableRow.tableHeaderCell.tableCell.anchor".split(".");
+//#endregion
+export { e as MARKDOWN_PARTS };

package/dist/components/MarkdownDocument/helpers/rehypeHeadingAnchors.d.ts

@@ -0,0 +1,8 @@
+import { HastNode } from './hastText';
+/** What decides a heading's id: its words, and the ids the document has already given. */
+export type HeadingAnchor = (text: string, taken: Set<string>) => string;
+/**
+ * Gives every heading the id `anchor` answers for its words, in document order — once per parse, so a heading keeps its
+ * id however many times React renders it.
+ */
+export declare const rehypeHeadingAnchors: (anchor: HeadingAnchor) => () => (tree: HastNode) => void;

package/dist/components/MarkdownDocument/helpers/rehypeHeadingAnchors.mjs

@@ -0,0 +1,20 @@
+import { hastText as e } from "./hastText.mjs";
+//#region src/components/MarkdownDocument/helpers/rehypeHeadingAnchors.ts
+var t = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]), n = (n) => () => (r) => {
+	let i = /* @__PURE__ */ new Set(), a = (r) => {
+		r.type === "element" && r.tagName && t.has(r.tagName) && (r.properties = {
+			...r.properties,
+			id: n(e(r).trim(), i)
+		}), r.children?.forEach(a);
+	};
+	a(r);
+};
+//#endregion
+export { n as rehypeHeadingAnchors };

package/dist/components/MarkdownDocument/helpers/syntaxHighlighter.d.ts

@@ -0,0 +1,3 @@
+import { PrismLight as SyntaxHighlighter } from 'react-syntax-highlighter';
+/** The highlighter a fenced block is drawn with, its languages registered once — the light build carries no others. */
+export { SyntaxHighlighter };

package/dist/components/MarkdownDocument/helpers/syntaxHighlighter.mjs

@@ -0,0 +1,24 @@
+import { PrismLight as e } from "react-syntax-highlighter";
+import t from "react-syntax-highlighter/dist/esm/languages/prism/bash";
+import n from "react-syntax-highlighter/dist/esm/languages/prism/css";
+import r from "react-syntax-highlighter/dist/esm/languages/prism/javascript";
+import i from "react-syntax-highlighter/dist/esm/languages/prism/json";
+import a from "react-syntax-highlighter/dist/esm/languages/prism/jsx";
+import o from "react-syntax-highlighter/dist/esm/languages/prism/markup";
+import s from "react-syntax-highlighter/dist/esm/languages/prism/tsx";
+import c from "react-syntax-highlighter/dist/esm/languages/prism/typescript";
+//#region src/components/MarkdownDocument/helpers/syntaxHighlighter.ts
+var l = (e) => typeof e == "object" && e && "default" in e ? e.default : e, u = {
+	javascript: r,
+	typescript: c,
+	jsx: a,
+	tsx: s,
+	bash: t,
+	json: i,
+	css: n,
+	html: o,
+	markdown: o
+};
+for (let [t, n] of Object.entries(u)) e.registerLanguage(t, l(n));
+//#endregion
+export { e as SyntaxHighlighter };

package/dist/components/MarkdownDocument/index.d.ts

@@ -0,0 +1,5 @@
+import { default as MarkdownDocument } from './MarkdownDocument';
+export * from './MarkdownDocument';
+export * from './helpers/markdownParts';
+export type { HeadingAnchor } from './helpers/rehypeHeadingAnchors';
+export default MarkdownDocument;

package/dist/components/MarkdownDocument/index.mjs

@@ -0,0 +1,6 @@
+import e from "./MarkdownDocument.mjs";
+import { MARKDOWN_PARTS as t } from "./helpers/markdownParts.mjs";
+//#region src/components/MarkdownDocument/index.ts
+var n = e;
+//#endregion
+export { t as MARKDOWN_PARTS, n as default };