@shivaedev/work-board 0.10.0 → 0.12.0

package/src/rpc/server.ts

@@ -1,67 +0,0 @@
-import { Clock, Effect, Layer, Ref } from "effect";
-import { HttpIncomingMessage, HttpServerResponse } from "effect/unstable/http";
-import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
-import type { Changes } from "#files/changes.ts";
-import type { handoffService } from "#handoffs/service.ts";
-import { MAX_BYTES } from "#history/limits.ts";
-import { historyResponse } from "#history/response.ts";
-import { HEADERS } from "#http/respond.ts";
-import { navHtml } from "#page/nav.ts";
-import type { responseService } from "#responses/service.ts";
-import { searchMatch } from "#search/match.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { ReadFailed, workRpcs } from "./contract.ts";
-import { hints } from "./hints.ts";
-
-export interface ServerOptions {
-	readonly changes: Changes;
-	readonly handoffs: Effect.Success<ReturnType<typeof handoffService>>;
-	readonly home: string | undefined;
-	readonly index: Effect.Effect<Snapshot, unknown>;
-	readonly page: (url: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>;
-	readonly responses: Effect.Success<ReturnType<typeof responseService>>;
-}
-
-export const server = Effect.fn("WorkBoard.server")(function* ({ changes, handoffs, home, index, page, responses }: ServerOptions) {
-	const handlers = workRpcs.toLayer({
-		"work-board.awaitResponse": responses.awaitResponse,
-		"work-board.handoffSource": ({ item }) => handoffs.locate(item),
-		"work-board.handoffs": ({ item }) => handoffs.read(item),
-		"work-board.history": ({ action, baseline }) =>
-			Effect.gen(function* () {
-				const now = yield* Clock.currentTimeMillis;
-				const snapshot = action === "check" ? undefined : yield* index;
-				return historyResponse(baseline, now, snapshot);
-			}).pipe(Effect.catch(() => Effect.fail(new ReadFailed({ operation: "history", status: 500 })))),
-		"work-board.navigation": () =>
-			Effect.map(changes.files, (files) => navHtml(files, "", home)).pipe(
-				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "navigation", status: 500 }))),
-			),
-		"work-board.page": ({ url }) =>
-			page(url).pipe(
-				Effect.flatMap((response) => {
-					if (response.status >= 500 || response.body._tag !== "Uint8Array") {
-						return Effect.fail(new ReadFailed({ operation: "page", status: response.status }));
-					}
-					return Effect.succeed({ html: new TextDecoder().decode(response.body.body), status: response.status });
-				}),
-				Effect.catch((error) => Effect.fail(error instanceof ReadFailed ? error : new ReadFailed({ operation: "page", status: 500 }))),
-			),
-		"work-board.prepareHandoff": handoffs.prepare,
-		"work-board.question": ({ item, request }) => responses.locate(item, request),
-		"work-board.recordResponse": responses.record,
-		"work-board.registerQuestion": responses.register,
-		"work-board.responses": ({ question }) => responses.read(question),
-		"work-board.search": ({ query }) =>
-			Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable })).pipe(
-				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "search", status: 500 }))),
-			),
-		"work-board.subscribe": () => hints(changes, index),
-		"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })),
-	});
-	const handler = yield* RpcServer.toHttpEffect(workRpcs).pipe(Effect.provide(Layer.merge(handlers, RpcSerialization.layerNdjson)));
-	return handler.pipe(
-		Effect.provideService(HttpIncomingMessage.MaxBodySize, BigInt(4 * MAX_BYTES + 4096)),
-		Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)),
-	);
-});

package/src/search/attentionEntries.ts

@@ -1,22 +0,0 @@
-import type { MetadataDocument } from "#metadata/model.ts";
-import type { Entry } from "./entries.ts";
-
-export function attentionEntries(document: MetadataDocument, href: string): readonly Entry[] {
-	const requests = document.parsed.fields.attention ?? [];
-	return requests.flatMap((request, index) => {
-		if (requests.filter((other) => other.id === request.id).length !== 1) {
-			return [];
-		}
-		const line = document.parsed.lines[`attention.${index}`] ?? document.parsed.lines.attention;
-		return [
-			{
-				file: document.file,
-				href: `${href}#attention-request-${encodeURIComponent(request.id)}`,
-				kind: "passage",
-				...(line === undefined ? {} : { line }),
-				text: [request.reason, request.id, request.kind, request.state, ...request.responseFrom, ...request.unblocks].join(" "),
-				title: request.reason,
-			},
-		];
-	});
-}

package/src/search/entries.ts

@@ -1,58 +0,0 @@
-import { MarkdownAsync } from "react-markdown";
-import rehypeRaw from "rehype-raw";
-import remarkDirective from "remark-directive";
-import remarkGfm from "remark-gfm";
-import { fileUrl } from "#files/url.ts";
-import { boardOf } from "#render/board.ts";
-import { callouts } from "#render/callouts.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import { visualDocuments } from "#render/visualDocuments.ts";
-import { searchCollector } from "./collector.ts";
-import { linkCollector } from "./linkCollector.ts";
-
-export interface Entry {
-	readonly file: string;
-	readonly href: string;
-	readonly kind: "document" | "heading" | "passage";
-	readonly line?: number;
-	readonly text: string;
-	readonly title: string;
-}
-
-function fragmentLocation(source: string, fragment: string, bodyLine: number, seen: Map<string, number>): number | undefined {
-	const start = source.indexOf(fragment, seen.get(fragment) ?? 0);
-	if (start < 0) {
-		return undefined;
-	}
-	seen.set(fragment, start + fragment.length);
-	return bodyLine + source.slice(0, start).split("\n").length - 1;
-}
-
-export async function entriesOf(source: string, file: string, home: boolean, bodyLine = 1, links = new Set<string>()): Promise<readonly Entry[]> {
-	const headings = documentHeadings();
-	let fragmentLine: number | undefined = bodyLine;
-	let fragmentLength = 0;
-	const seenFragments = new Map<string, number>();
-	const { entries, plugin } = searchCollector(
-		file,
-		() => fragmentLine,
-		() => fragmentLength,
-	);
-	const board = home ? boardOf(source) : undefined;
-	const fragments = board
-		? [board.title, board.intro, ...board.sections.flatMap((section) => [section.heading, section.notes, ...section.items]), board.footer]
-		: [source];
-	for (const fragment of fragments) {
-		if (fragment) {
-			fragmentLength = fragment.split("\n").length;
-			fragmentLine = board ? fragmentLocation(source, fragment, bodyLine, seenFragments) : bodyLine;
-			await MarkdownAsync({
-				children: board?.definitions ? `${fragment}\n\n${board.definitions}` : fragment,
-				rehypePlugins: [rehypeRaw, headings.plugin, plugin, linkCollector(links)],
-				remarkPlugins: [remarkGfm, remarkDirective, visualDocuments, callouts],
-			});
-		}
-	}
-	const title = headings.entries.find((heading) => heading.depth === 1)?.title || file;
-	return [{ file, href: fileUrl(file), kind: "document", line: bodyLine, text: `${file} ${title}`, title }, ...entries];
-}

package/src/search/metadataEntries.ts

@@ -1,44 +0,0 @@
-import { fileUrl } from "#files/url.ts";
-import { identityUrl } from "#metadata/links.ts";
-import type { MetadataDocument, MetadataModel } from "#metadata/model.ts";
-import { attentionEntries } from "./attentionEntries.ts";
-import type { Entry } from "./entries.ts";
-
-function itemUrl(document: MetadataDocument, model: MetadataModel): string {
-	const id = document.parsed.fields.id;
-	return model.unavailable.length === 0 && id && model.ids.get(id)?.length === 1 ? identityUrl(id) : fileUrl(document.file);
-}
-export function metadataEntries(entries: readonly Entry[], documents: readonly MetadataDocument[], model: MetadataModel): readonly Entry[] {
-	const sources = new Map(documents.map((document) => [document.file, document]));
-	const enriched = entries.map((entry) => {
-		const document = sources.get(entry.file);
-		if (entry.kind !== "document" || !document) {
-			return entry;
-		}
-		const fields = document.parsed.fields;
-		return {
-			...entry,
-			href: itemUrl(document, model),
-			text: [entry.text, fields.id, fields.kind, fields.status, fields.owner, fields.nextAction].filter(Boolean).join(" "),
-		};
-	});
-	for (const document of documents) {
-		enriched.push(...attentionEntries(document, itemUrl(document, model)));
-		const criteria = document.parsed.fields.criteria ?? [];
-		for (const [index, criterion] of criteria.entries()) {
-			if (criteria.filter((item) => item.id === criterion.id).length !== 1) {
-				continue;
-			}
-			const line = document.parsed.lines[`criteria.${index}`] ?? document.parsed.lines.criteria;
-			enriched.push({
-				file: document.file,
-				href: `${itemUrl(document, model)}#criterion-${encodeURIComponent(criterion.id)}`,
-				kind: "passage",
-				...(line === undefined ? {} : { line }),
-				text: criterion.text,
-				title: criterion.text,
-			});
-		}
-	}
-	return enriched;
-}

package/src/search/snapshot.ts

@@ -1,59 +0,0 @@
-import { Effect, FileSystem, Option, Ref, Semaphore } from "effect";
-import type { Changes } from "#files/changes.ts";
-import { markdownPath } from "#files/markdownPath.ts";
-import { type MetadataDocument, metadataModel } from "#metadata/model.ts";
-import { metadataParse } from "#metadata/parse.ts";
-import { type Entry, entriesOf } from "./entries.ts";
-import { metadataEntries } from "./metadataEntries.ts";
-
-export interface Snapshot {
-	readonly documents: readonly MetadataDocument[];
-	readonly entries: readonly Entry[];
-	readonly model: ReturnType<typeof metadataModel>;
-	readonly revision: number;
-	readonly unavailable: readonly string[];
-}
-
-export const searchSnapshot = Effect.fn("WorkBoard.searchSnapshot")(function* (root: string, home: string | undefined, changes: Changes) {
-	const cached = yield* Ref.make<Snapshot | undefined>(undefined);
-	const semaphore = yield* Semaphore.make(1);
-	const read = Effect.gen(function* () {
-		const revision = yield* changes.revision;
-		const hit = yield* Ref.get(cached);
-		if (hit?.revision === revision && (yield* Ref.get(changes.watching))) {
-			return hit;
-		}
-		const fs = yield* FileSystem.FileSystem;
-		const files = yield* changes.files;
-		const entries: Entry[] = [];
-		const documents: MetadataDocument[] = [];
-		const unavailable: string[] = [];
-		for (const file of files) {
-			const found = yield* Effect.option(
-				Effect.gen(function* () {
-					const real = yield* markdownPath(root, changes.realRoot, file.path);
-					if (real === undefined) {
-						return undefined;
-					}
-					const source = yield* fs.readFileString(real);
-					const parsed = metadataParse(source);
-					const links = new Set<string>();
-					const rendered = yield* Effect.tryPromise(() => entriesOf(parsed.body, file.path, file.path === home, parsed.bodyLine, links));
-					return { links: [...links], parsed, rendered };
-				}),
-			);
-			if (Option.isSome(found) && found.value) {
-				documents.push({ file: file.path, links: found.value.links, parsed: found.value.parsed });
-				entries.push(...found.value.rendered);
-			} else {
-				unavailable.push(file.path);
-			}
-		}
-		const model = metadataModel(documents, unavailable, home ?? files[0]?.path);
-		const enriched = metadataEntries(entries, documents, model);
-		const snapshot = { documents, entries: enriched, model, revision, unavailable };
-		yield* Ref.set(cached, unavailable.length > 0 ? undefined : snapshot);
-		return snapshot;
-	});
-	return semaphore.withPermit(read);
-});

package/src/serve-cli.ts

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Effect, Layer, Option, Path } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
-import { HOST, serveBoard } from "./serve.ts";
-
-const VERSION = "0.10.0";
-
-const serve = Effect.fn("WorkBoard.serve")(function* (input: {
-	readonly dir: string;
-	readonly port: number;
-	readonly responses: boolean;
-	readonly home: Option.Option<string>;
-}) {
-	const path = yield* Path.Path;
-	return yield* Layer.launch(
-		serveBoard({ home: Option.getOrUndefined(input.home), port: input.port, responses: input.responses, root: path.resolve(input.dir) }),
-	);
-});
-
-const workBoard = Command.make(
-	"work-board",
-	{
-		dir: Argument.directory("dir", { mustExist: true }).pipe(Argument.withDescription("The folder of markdown files to serve")),
-		home: Flag.string("home").pipe(Flag.optional, Flag.withDescription("The file shown as a board at /, relative to the folder")),
-		port: Flag.integer("port").pipe(Flag.withDefault(4747), Flag.withDescription(`The port to listen on at ${HOST}`)),
-		responses: Flag.boolean("responses").pipe(
-			Flag.withDefault(false),
-			Flag.withDescription("Explicitly enable local durable question, response and handoff writes (Linux)"),
-		),
-	},
-	serve,
-).pipe(Command.withDescription("Serve a folder of markdown files as a live page that updates in place when a file changes."));
-
-export function runServe() {
-	Command.run(workBoard, { version: VERSION }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
-}

package/src/serve.ts

@@ -1,16 +0,0 @@
-import { createServer } from "node:http";
-import { NodeHttpServer } from "@effect/platform-node";
-import { Layer } from "effect";
-import { HttpRouter } from "effect/unstable/http";
-import { type BoardOptions, boardLayer } from "./board.ts";
-
-export const HOST = "127.0.0.1";
-
-export interface ServeOptions extends BoardOptions {
-	readonly port: number;
-}
-
-export const listenOn = (port: number) => NodeHttpServer.layer(createServer, { disablePreemptiveShutdown: true, host: HOST, port });
-
-export const serveBoard = (options: ServeOptions) =>
-	HttpRouter.serve(boardLayer(options), { disableLogger: true }).pipe(Layer.provideMerge(listenOn(options.port)));

package/src/views/items.ts

@@ -1,55 +0,0 @@
-import type { MetadataDocument } from "#metadata/model.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { fieldFilter, type State } from "./state.ts";
-
-export interface Item {
-	readonly document: MetadataDocument;
-	readonly id: string;
-	readonly title: string;
-}
-export function itemsOf(snapshot: Snapshot): readonly Item[] {
-	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
-	return [...snapshot.model.ids].flatMap(([id, documents]) => {
-		const document = documents.length === 1 ? documents[0] : undefined;
-		return document ? [{ document, id, title: titles.get(document.file) ?? document.file }] : [];
-	});
-}
-function matches(item: Item, state: State): boolean {
-	const fields = item.document.parsed.fields;
-	if (state.owner && fieldFilter(fields.owner) !== state.owner) {
-		return false;
-	}
-	if (state.status && fieldFilter(fields.status) !== state.status) {
-		return false;
-	}
-	const text = [item.id, item.title, fields.kind, fields.status, fields.owner, fields.nextAction]
-		.filter(Boolean)
-		.join(" ")
-		.normalize("NFKC")
-		.toLowerCase();
-	return state.query
-		.normalize("NFKC")
-		.toLowerCase()
-		.split(/\s+/u)
-		.filter(Boolean)
-		.every((term) => text.includes(term));
-}
-function order(item: Item, sort: State["sort"]): string | undefined {
-	return sort === "title" ? item.title : item.document.parsed.fields[sort];
-}
-const collator = new Intl.Collator("en", { numeric: true, sensitivity: "base" });
-export function filterItems(items: readonly Item[], state: State): readonly Item[] {
-	return items
-		.filter((item) => matches(item, state))
-		.sort((a, b) => {
-			const left = order(a, state.sort);
-			const right = order(b, state.sort);
-			if (left === undefined) {
-				return right === undefined ? a.id.localeCompare(b.id) : 1;
-			}
-			if (right === undefined) {
-				return -1;
-			}
-			return collator.compare(left, right) || a.id.localeCompare(b.id);
-		});
-}

package/src/views/projection.ts

@@ -1,59 +0,0 @@
-import type { Snapshot } from "#search/snapshot.ts";
-import { filterItems, type Item, itemsOf } from "./items.ts";
-import type { State } from "./state.ts";
-
-export interface Projection {
-	readonly boards: readonly Item[];
-	readonly issues: readonly string[];
-	readonly items: readonly Item[];
-	readonly rows: readonly Item[];
-	readonly selected: Item | undefined;
-	readonly selectedOutside: boolean;
-	readonly title: string;
-	readonly validBoard: boolean;
-}
-function boardItems(board: Item, items: readonly Item[], snapshot: Snapshot) {
-	const references = board.document.parsed.fields.items ?? [];
-	const byId = new Map(items.map((item) => [item.id, item]));
-	const issues: string[] = [];
-	const found: Item[] = [];
-	for (const id of new Set(references)) {
-		const item = byId.get(id);
-		if (item) {
-			found.push(item);
-		} else {
-			issues.push(`${id}: ${(snapshot.model.ids.get(id)?.length ?? 0) > 1 ? "ambiguous ID" : "missing or invalid ID"}`);
-		}
-		if (references.filter((reference) => reference === id).length > 1) {
-			issues.push(`${id}: repeated membership, shown once`);
-		}
-	}
-	return { found, issues };
-}
-export function projectItems(snapshot: Snapshot, state: State): Projection {
-	const known = itemsOf(snapshot);
-	const boards = known.filter((item) => item.document.parsed.fields.kind === "board");
-	const board = boards.find((item) => item.id === state.board);
-	const membership = board ? boardItems(board, known, snapshot) : undefined;
-	const items = membership?.found ?? known.filter((item) => item.document.parsed.fields.kind !== "board");
-	const rows = filterItems(items, state);
-	const selected = known.find((item) => item.id === state.item);
-	const issues =
-		membership?.issues
-		?? [...snapshot.model.ids]
-			.filter(([, documents]) => documents.length > 1)
-			.map(([id]) => `${id}: ambiguous ID; open its source files to correct the declaration`);
-	const sourceIssues = board
-		? (snapshot.model.diagnostics.get(board.document.file) ?? []).map((problem) => `${board.document.file}:${problem.line}: ${problem.message}`)
-		: [];
-	return {
-		boards,
-		issues: [...issues, ...sourceIssues],
-		items,
-		rows,
-		selected,
-		selectedOutside: selected !== undefined && !rows.some((item) => item.id === selected.id),
-		title: board?.title ?? "All work",
-		validBoard: !state.board || board !== undefined,
-	};
-}

package/src/views/tools.ts

@@ -1,11 +0,0 @@
-import { escapeHtml } from "#page/escape.ts";
-import { type State, viewUrl } from "./state.ts";
-
-export function viewTools(state: State): string {
-	const layouts = ["board", "table"] as const;
-	return `<nav class="view-layouts" aria-label="Work layout">${layouts.map((view) => `<a href="${escapeHtml(viewUrl(state, { view }, "work-results"))}"${state.view === view ? ' aria-current="page"' : ""}>${view === "board" ? "Board" : "Table"}</a>`).join("")}</nav>
- <section id="saved-work-views" class="saved-work-views" aria-label="Saved local views" data-url="${escapeHtml(viewUrl(state, { item: "" }))}">
- <form id="save-work-view"><label for="view-name">View name</label><input id="view-name" maxlength="60" placeholder="Name this view" required><button type="submit" disabled>Save view</button></form>
- <div class="view-picker"><label for="saved-view">Saved views</label><select id="saved-view" disabled><option value="">No saved views</option></select><a id="open-saved-view" hidden>Open</a><button id="remove-saved-view" type="button" disabled>Remove</button><button id="clear-saved-views" type="button" disabled>Clear all</button></div>
- <p id="saved-view-status" role="status">Save board, filters, sort, and layout locally. Item selection stays in the URL. Saving requires JavaScript.</p></section>`;
-}

package/src/views/workCards.ts

@@ -1,26 +0,0 @@
-import { escapeHtml } from "#page/escape.ts";
-import type { Item } from "./items.ts";
-import { type State, viewUrl } from "./state.ts";
-
-function card(item: Item, state: State): string {
-	const fields = item.document.parsed.fields;
-	const selected = item.id === state.item;
-	return `<article class="work-card" data-key="item:${escapeHtml(item.id)}" data-item="${escapeHtml(item.id)}"${selected ? ' data-selected="true"' : ""}>
- <p class="work-kind">${escapeHtml(fields.kind ?? "Kind not recorded")}</p>
- <h3><a href="${escapeHtml(viewUrl(state, { item: item.id }, "work-detail"))}"${selected ? ' aria-current="true"' : ""}>${escapeHtml(item.title)}</a></h3>
- <p class="work-id">${escapeHtml(item.id)}</p><p class="work-owner">Owner: ${escapeHtml(fields.owner ?? "Not recorded")}</p>
- ${fields.nextAction ? `<p class="work-next">Next: ${escapeHtml(fields.nextAction)}</p>` : ""}</article>`;
-}
-export function workCards(items: readonly Item[], state: State): string {
-	if (items.length === 0) {
-		return '<p class="empty">No work matches these filters.</p>';
-	}
-	const columns = Map.groupBy(items, (item) => item.document.parsed.fields.status);
-	return `<div class="work-columns">${[...columns]
-		.map(
-			([status, rows]) => `<section class="work-column" data-key="status:${escapeHtml(status ?? "")}"
- aria-label="${escapeHtml(status ?? "Status not recorded")}"><h2>${escapeHtml(status ?? "Status not recorded")} <span class="work-count">${rows.length}</span></h2>
- ${rows.map((item) => card(item, state)).join("")}</section>`,
-		)
-		.join("")}</div>`;
-}

package/src/views/workControls.ts

@@ -1,38 +0,0 @@
-import { escapeHtml } from "#page/escape.ts";
-import type { Item } from "./items.ts";
-import type { Projection } from "./projection.ts";
-import { fieldFilter, type State, viewUrl } from "./state.ts";
-
-function option(value: string, title: string, current: string): string {
-	return `<option value="${escapeHtml(value)}"${value === current ? " selected" : ""}>${escapeHtml(title)}</option>`;
-}
-function fieldOptions(items: readonly Item[], field: "owner" | "status", current: string): string {
-	const values = new Map(
-		items.map((item) => {
-			const value = item.document.parsed.fields[field];
-			return [fieldFilter(value), value ?? `${field === "owner" ? "Owner" : "Status"} not recorded`];
-		}),
-	);
-	if (current && !values.has(current)) {
-		values.set(current, `${current.startsWith("value:") ? current.slice(6) : current} (no current matches)`);
-	}
-	return (
-		option("", `All ${field === "owner" ? "owners" : "statuses"}`, current)
-		+ [...values]
-			.sort((a, b) => a[1].localeCompare(b[1], "en"))
-			.map(([value, label]) => option(value, label, current))
-			.join("")
-	);
-}
-export function workControls(projection: Projection, state: State): string {
-	const boards = option("", "All work", state.board) + projection.boards.map((board) => option(board.id, board.title, state.board)).join("");
-	const unavailable = state.board && !projection.validBoard ? option(state.board, `${state.board} (unavailable)`, state.board) : "";
-	return `<form id="work-filters" class="work-filters" action="/_board/work#work-results" method="get">
- <input type="hidden" name="view" value="${state.view}"><input type="hidden" name="item" value="${escapeHtml(state.item)}">
- <label><span>Board</span><select name="board" id="work-board">${boards}${unavailable}</select></label>
- <label><span>Status</span><select name="status" id="work-status">${fieldOptions(projection.items, "status", state.status)}</select></label>
- <label><span>Owner</span><select name="owner" id="work-owner">${fieldOptions(projection.items, "owner", state.owner)}</select></label>
- <label><span>Find work</span><input name="q" id="work-query" type="search" value="${escapeHtml(state.query)}" maxlength="200"></label>
- <label><span>Sort by</span><select name="sort" id="work-sort">${["title", "owner", "status"].map((sort) => option(sort, sort.charAt(0).toUpperCase() + sort.slice(1), state.sort)).join("")}</select></label>
- <button type="submit">Apply</button><a href="${escapeHtml(viewUrl(state, { owner: "", query: "", status: "" }, "work-results"))}">Clear filters</a></form>`;
-}

package/src/views/workDetail.ts

@@ -1,28 +0,0 @@
-import { Effect } from "effect";
-import { identityUrl } from "#metadata/links.ts";
-import { escapeHtml } from "#page/escape.ts";
-import { metadataHtml } from "#page/metadata.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import type { Projection } from "./projection.ts";
-import { type State, viewUrl } from "./state.ts";
-
-export const workDetail = Effect.fn("WorkBoard.workDetail")(function* (projection: Projection, state: State, snapshot: Snapshot) {
-	if (!state.item) {
-		return "";
-	}
-	const close = `<a class="detail-close" href="${escapeHtml(viewUrl(state, { item: "" }, "work-results"))}">Close detail</a>`;
-	const selected = projection.selected;
-	if (!selected) {
-		const ambiguous = (snapshot.model.ids.get(state.item)?.length ?? 0) > 1;
-		return `<aside id="work-detail" class="work-detail" tabindex="-1" aria-label="Selected work">${close}<h2>Item unavailable</h2><p>${escapeHtml(state.item)} ${ambiguous ? "has a duplicate ID" : "is missing or its identity changed"}. No source was selected.</p><a href="${escapeHtml(identityUrl(state.item))}">Inspect item identity</a></aside>`;
-	}
-	const { document } = selected;
-	const prose = yield* renderMarkdown(document.parsed.body, { file: document.file, headings: documentHeadings() });
-	return `<aside id="work-detail" class="work-detail" data-key="detail:${escapeHtml(selected.id)}" tabindex="-1" aria-label="Selected work">
- <header>${close}<a href="${escapeHtml(identityUrl(selected.id))}">Open document</a></header>
- ${projection.selectedOutside ? '<p class="detail-notice" role="status">This selected item is outside the current board or filters.</p>' : ""}
- <p class="meta">Source: ${escapeHtml(document.file)}</p>${metadataHtml(document.parsed, document.file, snapshot.model)}
- <article class="doc">${prose}</article></aside>`;
-});

package/src/views/workHtml.ts

@@ -1,39 +0,0 @@
-import { Effect } from "effect";
-import { identityUrl } from "#metadata/links.ts";
-import { escapeHtml } from "#page/escape.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { projectItems } from "./projection.ts";
-import type { State } from "./state.ts";
-import { viewTools } from "./tools.ts";
-import { workCards } from "./workCards.ts";
-import { workControls } from "./workControls.ts";
-import { workDetail } from "./workDetail.ts";
-import { workTable } from "./workTable.ts";
-
-export const workHtml = Effect.fn("WorkBoard.workHtml")(function* (snapshot: Snapshot, state: State) {
-	const projection = projectItems(snapshot, state);
-	const controls = workControls(projection, state);
-	const tools = viewTools(state);
-	if (!projection.validBoard) {
-		return {
-			html: `<h1>Board unavailable</h1>${tools}${controls}<p class="empty">${escapeHtml(state.board)} is missing, has a duplicate ID, or is not a declared board. Choose another board or open its <a href="${escapeHtml(identityUrl(state.board))}">source identity</a>.</p>`,
-			status: 404,
-		};
-	}
-	const issues =
-		projection.issues.length > 0
-			? `<details class="view-issues"><summary>Source issues (${projection.issues.length})</summary><ul>${projection.issues.map((issue) => `<li>${escapeHtml(issue)}</li>`).join("")}</ul></details>`
-			: "";
-	const source = state.board ? `<a href="${escapeHtml(identityUrl(state.board))}">Board source</a>` : "";
-	const empty =
-		projection.items.length === 0
-			? '<p class="empty">No identified work is declared here. Keep reading ordinary files, or add item IDs and explicit board membership in their Markdown sources.</p>'
-			: "";
-	const detail = yield* workDetail(projection, state, snapshot);
-	return {
-		html: `<header class="work-head"><p class="work-eyebrow">WORK · ${state.view.toUpperCase()} VIEW</p><h1>${escapeHtml(projection.title)}</h1><p>Views use recorded fields. A section heading does not set an item's status.</p>${source}</header>
- ${tools}${controls}${issues}<p class="work-total" role="status">${projection.rows.length} shown · ${projection.items.length} items in this view</p>
- <div class="work-layout${state.item ? " has-detail" : ""}"><section id="work-results" tabindex="-1" aria-label="Work items">${empty}${state.view === "table" ? workTable(projection.rows, state) : workCards(projection.rows, state)}</section>${detail}</div>`,
-		status: 200,
-	};
-});

package/src/views/workTable.ts

@@ -1,21 +0,0 @@
-import { escapeHtml } from "#page/escape.ts";
-import type { Item } from "./items.ts";
-import { type State, viewUrl } from "./state.ts";
-
-function row(item: Item, state: State): string {
-	const fields = item.document.parsed.fields;
-	const selected = item.id === state.item;
-	const values = [fields.kind, fields.status, fields.owner, fields.nextAction];
-	return `<tr data-item="${escapeHtml(item.id)}"${selected ? ' data-selected="true"' : ""}>
- <th scope="row"><a href="${escapeHtml(viewUrl(state, { item: item.id }, "work-detail"))}"${selected ? ' aria-current="true"' : ""}>${escapeHtml(item.title)}</a><span class="work-id">${escapeHtml(item.id)}</span></th>
- ${values.map((value) => `<td>${escapeHtml(value ?? "Not recorded")}</td>`).join("")}</tr>`;
-}
-
-export function workTable(items: readonly Item[], state: State): string {
-	if (items.length === 0) {
-		return '<p class="empty">No work matches these filters.</p>';
-	}
-	return `<div class="work-table-wrap"><table class="work-table"><caption class="sr-only">Identified work, sorted by ${escapeHtml(state.sort)}</caption>
- <thead><tr>${["Work", "Kind", "Status", "Owner", "Next action"].map((title) => `<th scope="col">${title}</th>`).join("")}</tr></thead>
- <tbody>${items.map((item) => row(item, state)).join("")}</tbody></table></div>`;
-}