wiki-formant 0.22.0 → 0.23.1

package/dist/react.js

@@ -137,8 +137,15 @@ export function TableOfContents({ containerSelector, headings: providedHeadings,
             // article per mutation is what makes a rail janky.
             timer = setTimeout(() => {
                 const root = document.querySelector(containerSelector);
-                if (!root)
+                // No container is an answer, not a reason to skip: a rail that bailed
+                // here kept the LAST page's headings, so a section index reached from
+                // one of its own articles listed that article's sections under "on this
+                // page". It only looked right when a loading skeleton happened to render
+                // the container and scan to nothing.
+                if (!root) {
+                    setScanned(prev => (prev.length ? [] : prev));
                     return;
+                }
                 const used = new Set();
                 const next = [];
                 for (const el of Array.from(root.querySelectorAll('h1, h2, h3'))) {
@@ -518,6 +525,134 @@ export function useTableSort(rows, config) {
     }, [sortKey, direction, toggle]);
     return { sorted, sortKey, direction, headerProps, toggle };
 }
+/**
+ * The header cell `useTableSort` drives: spread `headerProps(key)` onto it.
+ *
+ * The press target is a `<button>` inside the `<th>`, never the cell itself: a
+ * cell with an `onClick` cannot be reached or pressed from the keyboard, which
+ * is the state one of the two copies this replaced was in. The markup is the
+ * one `sortTables` in `wiki-formant/dom` writes for tables stored in articles,
+ * so one stylesheet rule keyed on `aria-sort` draws both kinds of arrow.
+ */
+export function SortHeader({ sortKey, onSort, active: _active, direction: _direction, 'aria-sort': ariaSort, label, icon, children, ...th }) {
+    return (_jsx("th", { scope: "col", ...th, "aria-sort": ariaSort, children: _jsxs("button", { type: "button", className: "sort-header", onClick: () => onSort(sortKey), title: label, "aria-label": label, children: [children, icon] }) }));
+}
+/**
+ * The five edits every block editor makes to its list, with stable callbacks.
+ *
+ * The list and its setter are read through refs written after render, so a row
+ * memoised on these callbacks does not re-render on every keystroke elsewhere
+ * — and the setter may be a `useState` setter or a parent's `onChange`, which
+ * is what the three copies this replaced were split between. Creating and
+ * duplicating a block stay with the caller, whose union it is.
+ */
+export function useBlockOperations(blocks, setBlocks, options) {
+    const [selectedIndex, setSelectedIndex] = useState(null);
+    const latest = useRef({ blocks, setBlocks, clone: options.duplicate });
+    useEffect(() => {
+        latest.current = { blocks, setBlocks, clone: options.duplicate };
+    });
+    const update = useCallback((i, block) => {
+        const { blocks, setBlocks } = latest.current;
+        setBlocks(blocks.map((b, j) => (j === i ? block : b)));
+    }, []);
+    const remove = useCallback((i) => {
+        const { blocks, setBlocks } = latest.current;
+        setBlocks(blocks.filter((_, j) => j !== i));
+        setSelectedIndex(null);
+    }, []);
+    const duplicate = useCallback((i) => {
+        const { blocks, setBlocks, clone } = latest.current;
+        const source = blocks[i];
+        if (source === undefined)
+            return;
+        setBlocks([...blocks.slice(0, i + 1), clone(source), ...blocks.slice(i + 1)]);
+        setSelectedIndex(i + 1);
+    }, []);
+    const move = useCallback((from, to) => {
+        const { blocks, setBlocks } = latest.current;
+        if (to < 0 || to >= blocks.length || from === to)
+            return;
+        const next = [...blocks];
+        const [moved] = next.splice(from, 1);
+        next.splice(to, 0, moved);
+        setBlocks(next);
+        setSelectedIndex(to);
+    }, []);
+    const insert = useCallback((block, at) => {
+        const { blocks, setBlocks } = latest.current;
+        const i = at ?? blocks.length;
+        setBlocks([...blocks.slice(0, i), block, ...blocks.slice(i)]);
+        setSelectedIndex(i);
+    }, []);
+    return { selectedIndex, setSelectedIndex, update, remove, duplicate, move, insert };
+}
+/**
+ * Move up, move down, duplicate, delete. Every button has an accessible name
+ * and the moves are disabled at the ends — the three bars this replaced had
+ * each of those only sometimes. Clicks do not bubble, so a row that selects on
+ * click is not also selected by pressing delete in it. Omit `icons.duplicate`
+ * for a bar without it.
+ */
+export function BlockActions({ index, total, ops, icons, className, buttonClassName, blockLabel }) {
+    const name = (verb, rest = '') => (blockLabel ? `${verb} ${blockLabel}${rest}` : `${verb}${rest}`);
+    const button = (label, icon, run, disabled = false) => (_jsx("button", { type: "button", className: buttonClassName, title: label, "aria-label": label, disabled: disabled, onClick: e => {
+            e.stopPropagation();
+            run();
+        }, children: icon }));
+    return (_jsxs("span", { className: className, children: [button(name('Move', ' up'), icons.up, () => ops.move(index, index - 1), index === 0), button(name('Move', ' down'), icons.down, () => ops.move(index, index + 1), index === total - 1), icons.duplicate !== undefined && button(name('Duplicate'), icons.duplicate, () => ops.duplicate(index)), button(name('Delete'), icons.remove, () => ops.remove(index))] }));
+}
+/**
+ * POST `{ revisionId }` to `endpoint`, the transport two of the wikis use; the
+ * third passes its server action instead.
+ */
+export function restoreViaPost(endpoint) {
+    return async (id) => {
+        try {
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ revisionId: id }),
+            });
+            if (res.ok)
+                return null;
+            const body = (await res.json().catch(() => null));
+            return body?.error ?? 'Restore failed.';
+        }
+        catch {
+            return 'Restore failed.';
+        }
+    };
+}
+/**
+ * Confirm, restore, report. Of the three copies one asked no confirmation, one
+ * dropped a failure silently, and one reported it through `alert`. A restore
+ * writes the old state forward as a new revision in all three, which is what
+ * the default question says.
+ */
+export function useRevisionRestore(restore, options) {
+    const [busyId, setBusyId] = useState(null);
+    const [error, setError] = useState(null);
+    const { onRestored, confirm = (label) => `Restore ${label}? The current state stays in the history.` } = options;
+    const run = useCallback(async (id, label) => {
+        const question = confirm(label);
+        if (question && !window.confirm(question))
+            return;
+        setBusyId(id);
+        setError(null);
+        try {
+            const failure = await restore(id);
+            if (failure)
+                setError(failure);
+            else
+                onRestored();
+        }
+        finally {
+            setBusyId(null);
+        }
+    }, [restore, onRestored, confirm]);
+    return { restore: run, busyId, error };
+}
 // ---- copy to clipboard ------------------------------------------------------
 /**
  * "Copied", then not, after a beat. Six call sites across three repos wrote the
@@ -619,10 +754,29 @@ export function RailShell({ children, prefix, label, className }) {
  * matched on the PATH ONLY, deliberately: `?edit=` and `?history=` are modes a
  * page enters, not destinations a rail selects, and reading them would drag
  * `useSearchParams` into a statically-rendered wiki.
+ *
+ * The path is decoded first. Next serves a catch-all route's prerender with the
+ * joined segments percent-encoded — `/wiki/tech%2Fcore-concepts` for
+ * `/wiki/tech/core-concepts` — so an encoded path matches neither its own href
+ * nor its section's prefix, and React does not patch a className on hydration.
+ * Both wikis were shipping every page below the top level with nothing in the
+ * rail marked, and it only came right if you arrived by client navigation.
  */
 export function isRailLinkActive(activePath, href, tree = false) {
-    return tree ? activePath === href || activePath.startsWith(`${href}/`) : activePath === href;
+    const path = decodePath(activePath);
+    return tree ? path === href || path.startsWith(`${href}/`) : path === href;
 }
+/** `decodeURIComponent` throws on a stray `%`; a path it cannot read is its own answer. */
+const decodePath = (path) => {
+    if (!path.includes('%'))
+        return path;
+    try {
+        return decodeURIComponent(path);
+    }
+    catch {
+        return path;
+    }
+};
 // ---- rendered-article passes --------------------------------------------------
 /**
  * The `wiki-formant/dom` passes over a rendered article: tab groups, copy

package/dist/sanitize.d.ts

@@ -27,17 +27,15 @@ export interface HtmlSanitizerOptions {
  */
 export declare function createHtmlSanitizer(options?: HtmlSanitizerOptions): (html: string) => string;
 /**
- * The core leaf types' HTML fields, cleaned: `content.text`, `codeTabs` code,
- * `linkGrid` group descriptions and `references` item text. Every other field
- * those blocks carry renders as a React text node and is escaped already.
+ * The core leaf types' HTML fields, cleaned: `content.text`, `linkGrid` group
+ * descriptions and `references` item text. Every other field those blocks
+ * carry renders as a React text node and is escaped already.
  *
  * Returns any other block untouched, so it drops straight into a
  * `mapBlockTree` pass — a repo whose own types render HTML cleans those itself.
  *
- * `codeTabs` code is treated as stored HTML, which is what the editor writes.
- * A wiki whose highlighter takes the code as SOURCE and escapes it on render
- * must not pass it through here — every `<T>` in a signature would go — and
- * cleans its other three fields with its own switch.
+ * `codeTabs` passes through: its `code` is source text, which `CodeTabsView`
+ * escapes. Cleaning it as HTML was a bug — every `<T>` in a signature went.
  */
 export declare function sanitizeCoreLeaf<B extends {
     type: string;

package/dist/sanitize.js

@@ -159,25 +159,21 @@ export function createHtmlSanitizer(options = {}) {
 const each = (v, map) => Array.isArray(v) ? v.map(item => (item && typeof item === 'object' ? map(item) : item)) : v;
 const str = (v) => typeof v === 'string';
 /**
- * The core leaf types' HTML fields, cleaned: `content.text`, `codeTabs` code,
- * `linkGrid` group descriptions and `references` item text. Every other field
- * those blocks carry renders as a React text node and is escaped already.
+ * The core leaf types' HTML fields, cleaned: `content.text`, `linkGrid` group
+ * descriptions and `references` item text. Every other field those blocks
+ * carry renders as a React text node and is escaped already.
  *
  * Returns any other block untouched, so it drops straight into a
  * `mapBlockTree` pass — a repo whose own types render HTML cleans those itself.
  *
- * `codeTabs` code is treated as stored HTML, which is what the editor writes.
- * A wiki whose highlighter takes the code as SOURCE and escapes it on render
- * must not pass it through here — every `<T>` in a signature would go — and
- * cleans its other three fields with its own switch.
+ * `codeTabs` passes through: its `code` is source text, which `CodeTabsView`
+ * escapes. Cleaning it as HTML was a bug — every `<T>` in a signature went.
  */
 export function sanitizeCoreLeaf(block, clean) {
     const b = block;
     switch (b.type) {
         case 'content':
             return str(b.text) ? { ...b, text: clean(b.text) } : block;
-        case 'codeTabs':
-            return { ...b, tabs: each(b.tabs, t => (str(t.code) ? { ...t, code: clean(t.code) } : t)) };
         case 'linkGrid':
             return {
                 ...b,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "The portable half of a wiki: derived taxonomy and facet controls, a version-negotiating MCP transport, markdown twins, block rendering, a rich-text editor engine, and conditional-GET plumbing.",
   "type": "module",
   "license": "MIT",
@@ -18,7 +18,9 @@
     "markdown",
     "agent"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "*.css"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -144,6 +146,7 @@
       "types": "./dist/x402.d.ts",
       "import": "./dist/x402.js"
     },
+    "./base.css": "./dist/base.css",
     "./block-views": {
       "types": "./dist/block-views.d.ts",
       "import": "./dist/block-views.js"
@@ -184,7 +187,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/base.css dist/base.css",
     "test": "npm run build && node --test 'test/*.test.js'"
   },
   "devDependencies": {