🌿 Collaborative wiki on ATProto
lichen.wiki
atproto
Add first version of link preview
+478
-15
+1
bun.lock
+1
bun.lock
+1
package.json
+1
package.json
+8
public/editor/editor.ts
+8
public/editor/editor.ts
···
1
+
import { autocompletion } from "@codemirror/autocomplete";
1
2
import { markdown } from "@codemirror/lang-markdown";
2
3
import { EditorState } from "@codemirror/state";
3
4
import { basicSetup, EditorView } from "codemirror";
···
5
6
import { renderPreview } from "./preview.ts";
6
7
import { createToolbar } from "./toolbar.ts";
7
8
import { showToast, syncBlobMetadata, uploadImage } from "./upload.ts";
9
+
import { wikilinkCompletion } from "./wikilink-autocomplete.ts";
8
10
9
11
let activeView: EditorView | null = null;
10
12
···
76
78
fileInput.accept = "image/jpeg,image/png,image/gif,image/webp";
77
79
fileInput.style.display = "none";
78
80
81
+
const wikiSlug = textarea.dataset["wikiSlug"];
82
+
const autocompleteExt = wikiSlug
83
+
? [autocompletion({ override: [wikilinkCompletion(wikiSlug)] })]
84
+
: [];
85
+
79
86
const view = new EditorView({
80
87
state: EditorState.create({
81
88
doc: textarea.value,
82
89
extensions: [
83
90
basicSetup,
84
91
markdown(),
92
+
...autocompleteExt,
85
93
EditorView.lineWrapping,
86
94
EditorView.updateListener.of((update) => {
87
95
if (update.docChanged) {
+76
public/editor/wikilink-autocomplete.ts
+76
public/editor/wikilink-autocomplete.ts
···
1
+
import type { Completion, CompletionSource } from "@codemirror/autocomplete";
2
+
3
+
interface NoteItem {
4
+
slug: string;
5
+
title: string;
6
+
}
7
+
8
+
interface HeadingItem {
9
+
text: string;
10
+
anchor: string;
11
+
level: number;
12
+
}
13
+
14
+
/** Matches the text inside an unclosed `[[` up to the cursor. */
15
+
const TRIGGER_RE = /\[\[([^[\]\n]*)$/;
16
+
17
+
/**
18
+
* CodeMirror autocomplete source: triggers inside `[[...`. Returns note titles
19
+
* by default; after the user types `#`, returns headings for the named note.
20
+
*/
21
+
export function wikilinkCompletion(wikiSlug: string): CompletionSource {
22
+
const endpoint = `/wiki/${encodeURIComponent(wikiSlug)}/-/link-suggest`;
23
+
24
+
return async (context) => {
25
+
const match = context.matchBefore(TRIGGER_RE);
26
+
if (!match) return null;
27
+
const inside = match.text.slice(2);
28
+
29
+
// Explicit trigger keeps the popup open even when `inside` is empty.
30
+
if (!inside && !context.explicit) return null;
31
+
32
+
const from = match.from + 2;
33
+
const hashIdx = inside.indexOf("#");
34
+
35
+
if (hashIdx !== -1) {
36
+
const noteSlug = inside.slice(0, hashIdx).trim();
37
+
const headingQuery = inside.slice(hashIdx + 1);
38
+
if (!noteSlug) return null;
39
+
const url = `${endpoint}?note=${encodeURIComponent(noteSlug)}&q=${encodeURIComponent(headingQuery)}`;
40
+
const items = await fetchItems<HeadingItem>(url, context.aborted);
41
+
if (!items) return null;
42
+
const options: Completion[] = items.map((h) => ({
43
+
label: `${"#".repeat(Math.min(h.level, 3))} ${h.text}`,
44
+
apply: `${noteSlug}#${h.text}]]`,
45
+
type: "property",
46
+
}));
47
+
return { from, to: context.pos, options, validFor: /^[^[\]\n]*$/ };
48
+
}
49
+
50
+
const url = `${endpoint}?q=${encodeURIComponent(inside)}`;
51
+
const items = await fetchItems<NoteItem>(url, context.aborted);
52
+
if (!items) return null;
53
+
const options: Completion[] = items.map((n) => ({
54
+
label: n.title,
55
+
detail: n.slug,
56
+
apply: `${n.slug}]]`,
57
+
type: "text",
58
+
}));
59
+
return { from, to: context.pos, options, validFor: /^[^[\]\n#]*$/ };
60
+
};
61
+
}
62
+
63
+
async function fetchItems<T>(
64
+
url: string,
65
+
aborted: boolean,
66
+
): Promise<T[] | null> {
67
+
if (aborted) return null;
68
+
try {
69
+
const res = await fetch(url, { credentials: "same-origin" });
70
+
if (!res.ok) return [];
71
+
const data = (await res.json()) as { items?: T[] };
72
+
return data.items ?? [];
73
+
} catch {
74
+
return null;
75
+
}
76
+
}
+51
src/lib/headings.ts
+51
src/lib/headings.ts
···
1
+
import { slugify } from "./slug.ts";
2
+
3
+
interface Heading {
4
+
text: string;
5
+
level: number;
6
+
anchor: string;
7
+
}
8
+
9
+
/**
10
+
* Allocate an anchor for `text`, disambiguating repeats by suffixing -1, -2, ...
11
+
* `seen` tracks how many times each base slug has been used so far in the doc.
12
+
*/
13
+
export function makeAnchor(text: string, seen: Map<string, number>): string {
14
+
const base = slugify(text);
15
+
if (!base) return base;
16
+
const n = seen.get(base) ?? 0;
17
+
seen.set(base, n + 1);
18
+
return n === 0 ? base : `${base}-${n}`;
19
+
}
20
+
21
+
const HEADING_RE = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
22
+
const FENCE_RE = /^(`{3,}|~{3,})/;
23
+
24
+
/** Extract ATX headings from markdown, skipping fenced code blocks. */
25
+
export function extractHeadings(md: string): Heading[] {
26
+
const out: Heading[] = [];
27
+
const seen = new Map<string, number>();
28
+
let fence: string | null = null;
29
+
for (const line of md.split("\n")) {
30
+
const fenceMatch = line.match(FENCE_RE);
31
+
if (fenceMatch) {
32
+
const marker = fenceMatch[1]?.[0];
33
+
if (fence === null) {
34
+
fence = marker ?? null;
35
+
} else if (marker === fence) {
36
+
fence = null;
37
+
}
38
+
continue;
39
+
}
40
+
if (fence !== null) continue;
41
+
const m = line.match(HEADING_RE);
42
+
if (!m) continue;
43
+
const level = m[1]?.length ?? 0;
44
+
const text = m[2]?.trim() ?? "";
45
+
if (!text) continue;
46
+
const anchor = makeAnchor(text, seen);
47
+
if (!anchor) continue;
48
+
out.push({ text, level, anchor });
49
+
}
50
+
return out;
51
+
}
+6
-2
src/lib/markdown.ts
+6
-2
src/lib/markdown.ts
···
1
1
import MarkdownIt from "markdown-it";
2
+
import { headingAnchorPlugin } from "./markdown/heading-anchor-plugin.ts";
2
3
import { type KatexPluginEnv, katexPlugin } from "./markdown/katex-plugin.ts";
3
4
import {
5
+
parseWikilink,
4
6
type WikilinkEnv,
5
7
wikilinkPlugin,
6
8
} from "./markdown/wikilink-plugin.ts";
···
54
56
}
55
57
56
58
md.use(wikilinkPlugin);
59
+
md.use(headingAnchorPlugin);
57
60
md.use(vizPlugin);
58
61
md.use(katexPlugin, { throwOnError: false });
59
62
md.use(youtubePlugin);
···
69
72
70
73
/**
71
74
* Extract unique wikilink target slugs from markdown content.
72
-
* Matches [[slug]] and [[slug|label]], returns deduplicated trimmed slugs.
75
+
* Matches [[slug]], [[slug|label]], and [[slug#heading]] — returns deduplicated
76
+
* trimmed slugs (heading suffix dropped, since backlinks are per-note).
73
77
*/
74
78
export function extractWikilinks(content: string): string[] {
75
79
const seen = new Set<string>();
···
79
83
const closeIdx = content.indexOf("]]", pos + 2);
80
84
if (closeIdx === -1) break;
81
85
const inner = content.slice(pos + 2, closeIdx);
82
-
const slug = (inner.includes("|") ? inner.split("|")[0] : inner)?.trim();
86
+
const { slug } = parseWikilink(inner);
83
87
if (slug) {
84
88
seen.add(slug);
85
89
}
+25
src/lib/markdown/heading-anchor-plugin.ts
+25
src/lib/markdown/heading-anchor-plugin.ts
···
1
+
import type MarkdownIt from "markdown-it";
2
+
import { makeAnchor } from "../headings.ts";
3
+
4
+
/**
5
+
* Adds an `id` attribute to every rendered heading, slugified from its text.
6
+
* Matches the anchor scheme used by the wikilink plugin so `[[slug#heading]]`
7
+
* lands on the right element.
8
+
*/
9
+
export function headingAnchorPlugin(mdi: MarkdownIt): void {
10
+
mdi.core.ruler.push("heading_anchor", (state) => {
11
+
const seen = new Map<string, number>();
12
+
const tokens = state.tokens;
13
+
for (let i = 0; i < tokens.length; i++) {
14
+
const open = tokens[i];
15
+
if (open?.type !== "heading_open") continue;
16
+
const inline = tokens[i + 1];
17
+
if (!inline || inline.type !== "inline") continue;
18
+
const text = inline.content.trim();
19
+
if (!text) continue;
20
+
const anchor = makeAnchor(text, seen);
21
+
if (!anchor) continue;
22
+
open.attrSet("id", anchor);
23
+
}
24
+
});
25
+
}
+26
-13
src/lib/markdown/wikilink-plugin.ts
+26
-13
src/lib/markdown/wikilink-plugin.ts
···
1
1
import type MarkdownIt from "markdown-it";
2
2
import type StateInline from "markdown-it/lib/rules_inline/state_inline.mjs";
3
3
import { escapeHtml } from "../html.ts";
4
+
import { slugify } from "../slug.ts";
4
5
5
6
export interface WikilinkEnv {
6
7
wikiSlug?: string;
7
8
}
8
9
10
+
/** Parse the inside of `[[...]]` into its slug / heading / label parts. */
11
+
export function parseWikilink(inner: string): {
12
+
slug: string;
13
+
heading: string | null;
14
+
label: string;
15
+
} {
16
+
const pipeIdx = inner.indexOf("|");
17
+
const target = (pipeIdx === -1 ? inner : inner.slice(0, pipeIdx)).trim();
18
+
const label = (pipeIdx === -1 ? inner : inner.slice(pipeIdx + 1)).trim();
19
+
const hashIdx = target.indexOf("#");
20
+
if (hashIdx === -1) {
21
+
return { slug: target, heading: null, label };
22
+
}
23
+
return {
24
+
slug: target.slice(0, hashIdx).trim(),
25
+
heading: target.slice(hashIdx + 1).trim() || null,
26
+
label,
27
+
};
28
+
}
29
+
9
30
export function wikilinkPlugin(mdi: MarkdownIt): void {
10
31
mdi.inline.ruler.push("wikilink", (state: StateInline, silent: boolean) => {
11
32
const src = state.src;
···
17
38
if (closeIdx === -1) return false;
18
39
19
40
if (!silent) {
20
-
const content = src.slice(pos + 2, closeIdx);
21
-
let slug: string;
22
-
let label: string;
23
-
if (content.includes("|")) {
24
-
const parts = content.split("|");
25
-
slug = parts[0] ?? content;
26
-
label = parts.slice(1).join("|");
27
-
} else {
28
-
slug = content;
29
-
label = content;
30
-
}
41
+
const inner = src.slice(pos + 2, closeIdx);
42
+
const { slug, heading, label } = parseWikilink(inner);
31
43
32
44
const env = state.env as WikilinkEnv;
33
45
const wikiSlug = env.wikiSlug;
34
-
const href = wikiSlug ? `/wiki/${wikiSlug}/${slug.trim()}` : slug.trim();
46
+
const base = wikiSlug ? `/wiki/${wikiSlug}/${slug}` : slug;
47
+
const href = heading ? `${base}#${slugify(heading)}` : base;
35
48
36
49
const token = state.push("html_inline", "", 0);
37
-
token.content = `<a href="${escapeHtml(href)}" class="wikilink">${escapeHtml(label.trim())}</a>`;
50
+
token.content = `<a href="${escapeHtml(href)}" class="wikilink">${escapeHtml(label)}</a>`;
38
51
}
39
52
40
53
state.pos = closeIdx + 2;
+35
src/server/routes/wiki.ts
+35
src/server/routes/wiki.ts
···
12
12
ImportError,
13
13
ValidationError,
14
14
} from "../../lib/errors.ts";
15
+
import { extractHeadings } from "../../lib/headings.ts";
15
16
import { t } from "../../lib/i18n/index.ts";
16
17
import { exportWikiZip } from "../../lib/import-export/export.ts";
17
18
import { importWikiAction } from "../../lib/import-export/import.ts";
···
32
33
import { shareOnBlueskyButton } from "../../views/share.ts";
33
34
import { wikiPage } from "../../views/wiki.ts";
34
35
import {
36
+
getCurrentNote,
35
37
getNoteWithCurrent,
36
38
getSidebarNotes,
37
39
listMembers,
38
40
listRequests,
39
41
} from "../db/queries/index.ts";
42
+
43
+
const LINK_SUGGEST_LIMIT = 20;
40
44
41
45
async function loadSettingsData(wikiSlug: string) {
42
46
const members = listMembers(wikiSlug);
···
200
204
}
201
205
await deleteWikiAction(ctx);
202
206
return redirect("/");
207
+
})
208
+
.get("/:wikiSlug/-/link-suggest", async ({ params, request, query }) => {
209
+
await resolveWikiContext(request, params.wikiSlug, "read");
210
+
const q = ((query["q"] as string | undefined) ?? "").toLowerCase().trim();
211
+
const noteSlug = (query["note"] as string | undefined) ?? null;
212
+
213
+
if (noteSlug) {
214
+
const current = getCurrentNote(params.wikiSlug, noteSlug);
215
+
if (!current) {
216
+
return Response.json({ items: [] });
217
+
}
218
+
const headings = extractHeadings(current.content);
219
+
const filtered = q
220
+
? headings.filter((h) => h.text.toLowerCase().includes(q))
221
+
: headings;
222
+
return Response.json({
223
+
items: filtered.slice(0, LINK_SUGGEST_LIMIT),
224
+
});
225
+
}
226
+
227
+
const notes = getSidebarNotes(params.wikiSlug);
228
+
const filtered = q
229
+
? notes.filter(
230
+
(n) =>
231
+
n.title.toLowerCase().includes(q) ||
232
+
n.slug.toLowerCase().includes(q),
233
+
)
234
+
: notes;
235
+
return Response.json({
236
+
items: filtered.slice(0, LINK_SUGGEST_LIMIT),
237
+
});
203
238
})
204
239
.get("/:wikiSlug/-/export", async ({ params, request }) => {
205
240
await resolveWikiContext(request, params.wikiSlug, "read");
+1
src/views/edit-note.ts
+1
src/views/edit-note.ts
+1
src/views/new-note.ts
+1
src/views/new-note.ts
+65
tests/lib/headings.test.ts
+65
tests/lib/headings.test.ts
···
1
+
import { describe, expect, test } from "bun:test";
2
+
import { extractHeadings, makeAnchor } from "../../src/lib/headings.ts";
3
+
4
+
describe("makeAnchor", () => {
5
+
test("slugifies plain text", () => {
6
+
const seen = new Map<string, number>();
7
+
expect(makeAnchor("Hello World", seen)).toBe("hello-world");
8
+
});
9
+
10
+
test("suffixes repeats with -1, -2, ...", () => {
11
+
const seen = new Map<string, number>();
12
+
expect(makeAnchor("Intro", seen)).toBe("intro");
13
+
expect(makeAnchor("Intro", seen)).toBe("intro-1");
14
+
expect(makeAnchor("Intro", seen)).toBe("intro-2");
15
+
});
16
+
17
+
test("returns empty for text that slugifies to empty", () => {
18
+
const seen = new Map<string, number>();
19
+
expect(makeAnchor(" ", seen)).toBe("");
20
+
});
21
+
});
22
+
23
+
describe("extractHeadings", () => {
24
+
test("returns empty for no headings", () => {
25
+
expect(extractHeadings("just paragraphs\n\nmore text")).toEqual([]);
26
+
expect(extractHeadings("")).toEqual([]);
27
+
});
28
+
29
+
test("captures level, text, and anchor", () => {
30
+
const md = "# One\n\n## Two\n\n### Three";
31
+
expect(extractHeadings(md)).toEqual([
32
+
{ text: "One", level: 1, anchor: "one" },
33
+
{ text: "Two", level: 2, anchor: "two" },
34
+
{ text: "Three", level: 3, anchor: "three" },
35
+
]);
36
+
});
37
+
38
+
test("strips trailing ATX closing hashes", () => {
39
+
expect(extractHeadings("# Title ##")[0]?.text).toBe("Title");
40
+
});
41
+
42
+
test("requires a space after the hashes", () => {
43
+
expect(extractHeadings("#notaheading")).toEqual([]);
44
+
});
45
+
46
+
test("ignores headings inside fenced code blocks", () => {
47
+
const md = "# Real\n\n```\n# Fake\n```\n\n## AlsoReal";
48
+
const out = extractHeadings(md);
49
+
expect(out.map((h) => h.text)).toEqual(["Real", "AlsoReal"]);
50
+
});
51
+
52
+
test("handles tilde fences", () => {
53
+
const md = "~~~\n# Fake\n~~~\n# Real";
54
+
expect(extractHeadings(md).map((h) => h.text)).toEqual(["Real"]);
55
+
});
56
+
57
+
test("disambiguates duplicate anchors", () => {
58
+
const md = "# Intro\n\n## Intro\n\n### Intro";
59
+
expect(extractHeadings(md).map((h) => h.anchor)).toEqual([
60
+
"intro",
61
+
"intro-1",
62
+
"intro-2",
63
+
]);
64
+
});
65
+
});
+36
tests/lib/markdown.test.ts
+36
tests/lib/markdown.test.ts
···
110
110
expect(html).not.toContain("<img");
111
111
expect(html).toContain("<img");
112
112
});
113
+
114
+
test("renders [[slug#heading]] with anchor fragment and default label", () => {
115
+
const { html } = renderMarkdown("see [[my-page#My Heading]]", WIKI);
116
+
expect(html).toContain('href="/wiki/test-wiki/my-page#my-heading"');
117
+
expect(html).toContain(">my-page#My Heading<");
118
+
});
119
+
120
+
test("renders [[slug#heading|label]] with custom label", () => {
121
+
const { html } = renderMarkdown("see [[my-page#Intro|Jump]]", WIKI);
122
+
expect(html).toContain('href="/wiki/test-wiki/my-page#intro"');
123
+
expect(html).toContain(">Jump<");
124
+
});
125
+
});
126
+
127
+
describe("heading anchors", () => {
128
+
test("attaches id to rendered headings", () => {
129
+
const { html } = renderMarkdown("# Hello World\n\n## Another One");
130
+
expect(html).toContain('<h1 id="hello-world">');
131
+
expect(html).toContain('<h2 id="another-one">');
132
+
});
133
+
134
+
test("disambiguates duplicate heading anchors", () => {
135
+
const { html } = renderMarkdown("# Intro\n\n## Intro\n\n### Intro");
136
+
expect(html).toContain('<h1 id="intro">');
137
+
expect(html).toContain('<h2 id="intro-1">');
138
+
expect(html).toContain('<h3 id="intro-2">');
139
+
});
113
140
});
114
141
115
142
describe("extractWikilinks", () => {
···
144
171
test("handles wikilinks across multiple lines", () => {
145
172
const result = extractWikilinks("line1 [[a]]\nline2 [[b]]");
146
173
expect(result).toEqual(["a", "b"]);
174
+
});
175
+
176
+
test("strips #heading suffix when recording the slug", () => {
177
+
expect(extractWikilinks("jump to [[my-page#Section]]")).toEqual([
178
+
"my-page",
179
+
]);
180
+
expect(extractWikilinks("[[a#one]] and [[a#two]] and [[a]]")).toEqual([
181
+
"a",
182
+
]);
147
183
});
148
184
});
+146
tests/server/routes/link-suggest.test.ts
+146
tests/server/routes/link-suggest.test.ts
···
1
+
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
2
+
import {
3
+
createNote,
4
+
upsertMembership,
5
+
upsertWiki,
6
+
} from "../../../src/server/db/queries/index.ts";
7
+
import { cleanupWikiAndDependents } from "../../helpers/cleanup.ts";
8
+
import { authedRequest, createTestApp, TEST_DID } from "./helpers.ts";
9
+
10
+
const app = createTestApp();
11
+
12
+
const SLUG = "ls-test-wiki";
13
+
const AT_URI = `at://${TEST_DID}/wiki.lichen.wiki/${SLUG}`;
14
+
const PRIVATE_SLUG = "ls-test-private";
15
+
const OTHER_DID = "did:plc:other";
16
+
17
+
const NOTE_CONTENT = [
18
+
"# Intro",
19
+
"",
20
+
"Some text.",
21
+
"",
22
+
"## Installation Steps",
23
+
"",
24
+
"More text.",
25
+
"",
26
+
"## Running Tests",
27
+
].join("\n");
28
+
29
+
beforeAll(() => {
30
+
upsertWiki(
31
+
SLUG,
32
+
TEST_DID,
33
+
"Link Suggest Wiki",
34
+
"public",
35
+
AT_URI,
36
+
new Date().toISOString(),
37
+
);
38
+
upsertMembership(
39
+
SLUG,
40
+
TEST_DID,
41
+
"admin",
42
+
`at://${TEST_DID}/wiki.lichen.membership/ls1`,
43
+
new Date().toISOString(),
44
+
);
45
+
createNote(
46
+
`at://${TEST_DID}/wiki.lichen.note/ls-guide`,
47
+
`at://${TEST_DID}/wiki.lichen.noteRevision/ls-guide-rev`,
48
+
SLUG,
49
+
"guide",
50
+
"Setup Guide",
51
+
TEST_DID,
52
+
NOTE_CONTENT,
53
+
);
54
+
createNote(
55
+
`at://${TEST_DID}/wiki.lichen.note/ls-faq`,
56
+
`at://${TEST_DID}/wiki.lichen.noteRevision/ls-faq-rev`,
57
+
SLUG,
58
+
"faq",
59
+
"FAQ",
60
+
TEST_DID,
61
+
"# Questions",
62
+
);
63
+
upsertWiki(
64
+
PRIVATE_SLUG,
65
+
OTHER_DID,
66
+
"Private Wiki",
67
+
"private",
68
+
`at://${OTHER_DID}/wiki.lichen.wiki/${PRIVATE_SLUG}`,
69
+
new Date().toISOString(),
70
+
);
71
+
});
72
+
73
+
afterAll(() => {
74
+
cleanupWikiAndDependents(SLUG);
75
+
cleanupWikiAndDependents(PRIVATE_SLUG);
76
+
});
77
+
78
+
async function getJson(url: string): Promise<{
79
+
status: number;
80
+
body: { items: unknown[] };
81
+
}> {
82
+
const res = await app.handle(new Request(url));
83
+
const body = (await res.json()) as { items: unknown[] };
84
+
return { status: res.status, body };
85
+
}
86
+
87
+
describe("link-suggest route", () => {
88
+
test("returns all wiki notes when q is empty", async () => {
89
+
const { status, body } = await getJson(
90
+
`http://localhost/wiki/${SLUG}/-/link-suggest`,
91
+
);
92
+
expect(status).toBe(200);
93
+
const titles = (body.items as { title: string }[]).map((n) => n.title);
94
+
expect(titles).toContain("Setup Guide");
95
+
expect(titles).toContain("FAQ");
96
+
});
97
+
98
+
test("filters notes by q (case-insensitive, title or slug)", async () => {
99
+
const { body } = await getJson(
100
+
`http://localhost/wiki/${SLUG}/-/link-suggest?q=guide`,
101
+
);
102
+
const titles = (body.items as { title: string }[]).map((n) => n.title);
103
+
expect(titles).toContain("Setup Guide");
104
+
expect(titles).not.toContain("FAQ");
105
+
});
106
+
107
+
test("returns headings when note param is provided", async () => {
108
+
const { body } = await getJson(
109
+
`http://localhost/wiki/${SLUG}/-/link-suggest?note=guide`,
110
+
);
111
+
const items = body.items as { text: string; anchor: string }[];
112
+
const texts = items.map((h) => h.text);
113
+
expect(texts).toEqual(["Intro", "Installation Steps", "Running Tests"]);
114
+
expect(items[0]?.anchor).toBe("intro");
115
+
expect(items[1]?.anchor).toBe("installation-steps");
116
+
});
117
+
118
+
test("filters headings by q", async () => {
119
+
const { body } = await getJson(
120
+
`http://localhost/wiki/${SLUG}/-/link-suggest?note=guide&q=install`,
121
+
);
122
+
const items = body.items as { text: string }[];
123
+
expect(items.map((h) => h.text)).toEqual(["Installation Steps"]);
124
+
});
125
+
126
+
test("returns empty items for unknown note", async () => {
127
+
const { body } = await getJson(
128
+
`http://localhost/wiki/${SLUG}/-/link-suggest?note=does-not-exist`,
129
+
);
130
+
expect(body.items).toEqual([]);
131
+
});
132
+
133
+
test("403s for private wiki without membership", async () => {
134
+
const res = await app.handle(
135
+
new Request(`http://localhost/wiki/${PRIVATE_SLUG}/-/link-suggest`),
136
+
);
137
+
expect(res.status).toBe(403);
138
+
});
139
+
140
+
test("accepts authed member on a wiki they can read", async () => {
141
+
const res = await app.handle(
142
+
authedRequest(`http://localhost/wiki/${SLUG}/-/link-suggest`),
143
+
);
144
+
expect(res.status).toBe(200);
145
+
});
146
+
});