caracms 0.3.3 → 0.4.0

package/src/editor/client/fields/HiddenToggle.tsx

@@ -7,11 +7,16 @@
  *   which can't be hidden.
  * - A page under a hidden page is hidden with it (content.ts → `hiddenBy`): the switch shows
  *   on and can't be turned off here, and its help names the page to show again.
+ * - Collections under pages (Decision 5): a page that holds a collection says so beside it,
+ *   "Holds Journal (24)" (every document, hidden ones included). Nothing here changes it:
+ *   the `holds` line is the file's, a developer's call.
  */
 import { useMemo } from 'react';
 import { useEditor, useStore } from '../context.tsx';
 import { FieldFrame } from './FieldFrame.tsx';
 import { FieldHostProvider, type FieldHost } from './host.tsx';
+import { docIcon } from '../nav/DocRow.tsx';
+import { Icon } from '../shell/Icons.tsx';
 
 const SCOPE = 'page-hidden';
 const NAME = 'hidden';
@@ -30,11 +35,14 @@ export function HiddenToggle() {
 	const collection = editor.site.collections.find((c) => c.name === ref.collection);
 	if (kind !== 'sections' || !collection?.urlBase || ref.path === 'index') return null;
 	const listed = documents.find((d) => d.collection === ref.collection && d.path === ref.path);
-	const by = listed?.hiddenBy ? documents.find((d) => d.collection === ref.collection && d.path === listed.hiddenBy) : undefined;
+	// Collections under pages (Decision 11): a held document is hidden with the page that holds its collection.
+	const byCollection = listed?.hiddenByCollection ?? ref.collection;
+	const by = listed?.hiddenBy ? documents.find((d) => d.collection === byCollection && d.path === listed.hiddenBy) : undefined;
 	const on = hidden || !!by;
+	const holds = listed?.holds ? editor.site.collections.find((c) => c.name === listed.holds && c.heldBy === ref.collection) : undefined;
 	const id = `f-${SCOPE}-${NAME}`;
 	const help = by
-		? `Hidden with ${by.label}, the page it's under. Show that page again to show this one.`
+		? `Hidden with ${by.label}, the page ${listed?.hiddenByCollection ? `that holds ${collection.label}` : "it's under"}. Show that page again to show this one.`
 		: 'Visitors get the 404 page, and it’s left out of the sitemap and the link picker. You can still edit, preview and publish it.';
 	return (
 		<div className="page-hidden" data-page-hidden={on ? 'on' : 'off'}>
@@ -46,6 +54,14 @@ export function HiddenToggle() {
 					</button>
 				</FieldFrame>
 			</FieldHostProvider>
+			{holds ? (
+				<p className="page-holds" data-holds={holds.name}>
+					<Icon name={docIcon(holds)} size="xs" />
+					<span>
+						Holds {holds.label} ({documents.filter((d) => d.collection === holds.name).length})
+					</span>
+				</p>
+			) : null}
 		</div>
 	);
 }

package/src/editor/client/nav/DocRow.tsx

@@ -26,6 +26,13 @@ export function docIcon(collection: { nested: boolean; kind?: string } | undefin
 	return 'journal';
 }
 
+/** A hidden document's mark's words: "Journal is hidden" for one hidden with the page that holds its collection (or the page it's under). */
+export function hiddenTitle(doc: ListedDocument, documents: readonly ListedDocument[]): string {
+	if (!doc.hiddenBy) return 'Hidden from the site';
+	const by = documents.find((d) => d.collection === (doc.hiddenByCollection ?? doc.collection) && d.path === doc.hiddenBy);
+	return by ? `${by.label} is hidden` : 'Hidden with the page it’s under';
+}
+
 export function DocRow(props: {
 	doc: ListedDocument;
 	crumb?: string;
@@ -84,7 +91,7 @@ export function DocRow(props: {
 					) : null}
 					{/* M9 Decision 7: hidden from the site (or under a hidden page). */}
 					{doc.hidden ? (
-						<span className="hmark" data-mark="hidden" title={doc.hiddenBy ? 'Hidden from the site with the page it’s under' : 'Hidden from the site'}>
+						<span className="hmark" data-mark="hidden" title={hiddenTitle(doc, editor.documents.get())}>
 							Hidden
 						</span>
 					) : null}

package/src/editor/client/nav/tree.ts

@@ -29,6 +29,22 @@ export type TreeRow =
 			/** Documents under it (any depth), for a bubbled mark when it's closed. */
 			under: ListedDocument[];
 	  }
+	| {
+			/**
+			 * Collections under pages (Decision 4): a collection the page above holds, as one row
+			 * (its name and count, opening its table), the first row under its holder whenever the
+			 * holder's row shows. Its documents never go in the tree.
+			 */
+			kind: 'held';
+			/** The holder's path (the row's position). */
+			path: string;
+			depth: number;
+			collection: string;
+			label: string;
+			/** Every document in it, hidden ones included (as its sidebar entry counts them). */
+			count: number;
+			files: string[];
+	  }
 	| {
 			/** A folder with no page of its own: shows or hides its children only. */
 			kind: 'group';
@@ -46,7 +62,13 @@ export type TreeRow =
  * closed group (at any depth) isn't returned. `documents` must be one collection's,
  * in the reader's order.
  */
-export function treeRows(collection: string, documents: readonly ListedDocument[], open: UiState['open']): TreeRow[] {
+export function treeRows(
+	collection: string,
+	documents: readonly ListedDocument[],
+	open: UiState['open'],
+	/** The collections pages of this one hold, each with its holder's path and its documents' files. */
+	held: readonly { collection: string; label: string; holder: string; files: string[] }[] = [],
+): TreeRow[] {
 	const paths = new Set(documents.map((d) => d.path));
 	const isOpen = (path: string) => open[groupKey(collection, path)] === true;
 	const under = (path: string) => documents.filter((d) => d.path.startsWith(`${path}/`));
@@ -88,6 +110,9 @@ export function treeRows(collection: string, documents: readonly ListedDocument[
 			key: groupKey(collection, doc.path),
 			under: kids,
 		});
+		for (const h of held) {
+			if (h.holder === doc.path) rows.push({ kind: 'held', path: doc.path, depth: segments.length, collection: h.collection, label: h.label, count: h.files.length, files: h.files });
+		}
 	}
 	return rows;
 }

package/src/editor/client/pane/levels/DocumentsLevel.tsx

@@ -103,7 +103,7 @@ export function DocumentsLevel() {
 					) : (
 						<>
 							{nested.map((c) => (
-								<PagesSection key={c.name} collection={c} documents={documents.filter((d) => d.collection === c.name)} />
+								<PagesSection key={c.name} collection={c} documents={documents.filter((d) => d.collection === c.name)} all={documents} />
 							))}
 							{flat.length > 0 ? (
 								<section className="grp" aria-label="Collections">
@@ -131,10 +131,14 @@ export function DocumentsLevel() {
 	);
 }
 
-function PagesSection({ collection, documents }: { collection: EditorCollection; documents: ListedDocument[] }) {
+function PagesSection({ collection, documents, all }: { collection: EditorCollection; documents: ListedDocument[]; all: ListedDocument[] }) {
 	const editor = useEditor();
 	const open = useStore(editor.ui, (u) => u.open);
-	const rows = treeRows(collection.name, documents, open);
+	// Collections under pages (Decision 4): each collection a page here holds, as a row under it.
+	const held = editor.site.collections
+		.filter((c) => c.heldBy === collection.name && c.holder?.collection === collection.name)
+		.map((c) => ({ collection: c.name, label: c.label, holder: c.holder!.path, files: all.filter((d) => d.collection === c.name).map((d) => d.file) }));
+	const rows = treeRows(collection.name, documents, open, held);
 	return (
 		<section className="grp" aria-label={collection.label} data-collection={collection.name}>
 			<div className="grp-h">
@@ -155,6 +159,22 @@ function PagesSection({ collection, documents }: { collection: EditorCollection;
 function TreeNode({ row, collection }: { row: TreeRow; collection: EditorCollection }) {
 	const editor = useEditor();
 	const depth = { ['--depth' as string]: row.depth };
+	if (row.kind === 'held') {
+		const held = editor.site.collections.find((c) => c.name === row.collection);
+		return (
+			<div className="tnode" data-tnode-held={row.collection}>
+				<button type="button" className="drow t coll is-held" style={depth} data-held={row.collection} aria-label={`${row.label}, ${row.count}`} title={`${row.label}, held by this page: its documents are at its address`} onClick={() => editor.openCollection(row.collection)}>
+					<Icon name={docIcon(held)} />
+					<span className="nm">{row.label}</span>
+					<span className="meta">
+						{editor.mode === 'live' ? <Bubble files={row.files} /> : <span data-slot="bubble" hidden />}
+						<span className="cnt">{row.count}</span>
+					</span>
+					<Icon name="chev-r" size="sm" />
+				</button>
+			</div>
+		);
+	}
 	if (row.kind === 'group') {
 		return (
 			<div className="tnode" data-tnode-group={row.path}>
@@ -344,17 +364,42 @@ function SubmissionsRow() {
 function CollectionRow({ collection, documents }: { collection: EditorCollection; documents: ListedDocument[] }) {
 	const editor = useEditor();
 	const n = documents.length;
+	// Collections under pages (Decision 13): a held collection no page holds (or two do) has no addresses; its entry says why.
+	const problem = collection.problem ?? null;
 	return (
-		<button type="button" className="drow coll" data-coll={collection.name} aria-label={`${collection.label}, ${n}`} onClick={() => editor.openCollection(collection.name)}>
-			<Icon name={docIcon(collection)} />
-			<span className="nm">{collection.label}</span>
-			<span className="meta">
-				{/* M4: presence and waiting dots inside the collection, bubbled up. */}
-				{editor.mode === 'live' ? <Bubble files={documents.map((d) => d.file)} /> : <span data-slot="bubble" hidden />}
-				<span className="cnt">{n}</span>
-			</span>
-			<Icon name="chev-r" size="sm" />
-		</button>
+		<>
+			<button
+				type="button"
+				className={problem ? 'drow coll is-warned' : 'drow coll'}
+				data-coll={collection.name}
+				aria-label={`${collection.label}, ${n}${problem ? ', has no addresses' : ''}`}
+				title={problem ?? undefined}
+				onClick={() => editor.openCollection(collection.name)}
+			>
+				<Icon name={docIcon(collection)} />
+				<span className="nm">{collection.label}</span>
+				<span className="meta">
+					{problem ? (
+						<span className="wmark" data-warning="not-held">
+							<Icon name="warn" size="xs" />
+						</span>
+					) : null}
+					{/* M4: presence and waiting dots inside the collection, bubbled up. */}
+					{editor.mode === 'live' ? <Bubble files={documents.map((d) => d.file)} /> : <span data-slot="bubble" hidden />}
+					<span className="cnt">{n}</span>
+				</span>
+				<Icon name="chev-r" size="sm" />
+			</button>
+			{problem ? (
+				<div className="note warn tight doc-why" role="note" data-why={`coll-${collection.name}`}>
+					<Icon name="warn" />
+					<div>
+						<b>{collection.label} has no addresses</b>
+						<p>{problem}</p>
+					</div>
+				</div>
+			) : null}
+		</>
 	);
 }
 

package/src/editor/client/pane/parts.tsx

@@ -107,12 +107,25 @@ function GitHubAccessNote() {
 			<Icon name="warn" />
 			<div>
 				<b>{access.title}</b>
-				<p>{access.message}</p>
+				<p>{withLink(access.message, access.link ?? null)}</p>
 			</div>
 		</div>
 	);
 }
 
+/** The sentence as it came, with `link` as a link where it names it (or after it); the words are never changed. */
+function withLink(message: string, link: string | null) {
+	if (!link) return message;
+	const a = (key: number) => (
+		<a key={key} href={link} target="_blank" rel="noopener noreferrer">
+			{link}
+		</a>
+	);
+	const parts = message.split(link);
+	if (parts.length === 1) return [message, ' ', a(0)];
+	return parts.flatMap((part, i) => (i === 0 ? [part] : [a(i), part]));
+}
+
 function KeepNotes() {
 	const editor = useEditor();
 	const state = useStore(editor.keep, (k) => k.state);

package/src/editor/routes/move.ts

@@ -1,5 +1,5 @@
 /**
- * POST /_caracms/move: `{ collection, path, to }` → MoveResponse, or `{ error, code }`
+ * POST /_caracms/move: `{ collection, path, to, redirect? }` → MoveResponse, or `{ error, code }`
  * (pre-M7 item 8; shapes: ../types.ts → MoveRequest). The rules are in ../server/move.ts;
  * the store is the mode's (server/mode.ts), as for create and delete: on disk in local
  * mode, autosaves under this tab's locks in live mode, where the request carries

package/src/editor/server/admin-props.ts

@@ -7,6 +7,7 @@ import { createHash } from 'node:crypto';
 import { relative } from 'node:path';
 import type { Brand, ResolvedSite } from '../../config.ts';
 import { DocumentError } from '../../content.ts';
+import { heldBases, withHeldBases } from '../../held.ts';
 import { inboxFromAddress, refFromAddress } from '../addresses.ts';
 import { handleSubmissions, SUBMISSIONS_PREFIX, submissionsSetupQuick, type SubmissionResponse, type SubmissionsListResponse } from '../../forms/inbox.ts';
 import { ENDPOINTS, type AdminProps, type DocRef, type EditorSite, type ListedDocument, type LiveProps, type MediaSetup, type EditorForm, type Person, type StatusResponse } from '../types.ts';
@@ -34,7 +35,24 @@ export function homeOf(site: Pick<ResolvedSite, 'collections'>, documents: reado
  */
 export function editorSite(site: ResolvedSite, documents: readonly ListedDocument[], host: string, brand: Brand): EditorSite {
 	// Every kind of collection (M5a Phase 5): the site's own in config order, then `shared` and `settings`.
-	const collections = Object.values(site.collections).map(({ name, label, kind, urlBase, nested, fields, columns, sort, view, blocks }) => ({ name, label, kind, urlBase, nested, fields, columns, sort: sort ?? null, view: view ?? null, blocks: blocks ?? null }));
+	// Collections under pages (Decision 7): a held collection's urlBase is resolved from the listing, so the browser never works one out.
+	const bases = heldBases(site.collections, documents);
+	const collections = Object.values(withHeldBases(site, bases).collections).map(({ name, label, kind, urlBase, nested, fields, columns, sort, view, blocks, heldBy }) => {
+		const held = heldBy ? bases[name] : undefined;
+		return {
+			name,
+			label,
+			kind,
+			urlBase,
+			nested,
+			fields,
+			columns,
+			sort: sort ?? null,
+			view: view ?? null,
+			blocks: blocks ?? null,
+			...(held ? { heldBy, holder: held.holder && !held.problem ? { collection: held.holder.collection, path: held.holder.path } : null, problem: held.problem } : {}),
+		};
+	});
 	return {
 		collections,
 		allCollections: collections,

package/src/editor/server/create.ts

@@ -46,6 +46,7 @@ import { link, lstat, mkdir, realpath, rm, rmdir, stat, unlink, writeFile } from
 import { basename, dirname, join, relative, sep } from 'node:path';
 import type { ResolvedCollection, ResolvedSite } from '../../config.ts';
 import { DocumentError, documentUrl, resolveDocumentFile, type DocumentEntry } from '../../content.ts';
+import { heldBases, holdsMessage, withHeldBases } from '../../held.ts';
 import { own, parseAnyDocument, type AnyDocument } from '../../document.ts';
 import type { Person } from '../../live/messages.ts';
 import { applyDocumentEdits } from '../../serialize.ts';
@@ -197,10 +198,15 @@ function firstText(site: Site, collection: ResolvedCollection, title: string, bl
  * Check a create against the rules and the store's listing (`documents`: every
  * document in every collection now), and work out the new file. Throws WriteRefused.
  */
-export function planCreate(site: Site, request: CreateRequest, documents: readonly DocumentEntry[]): CreatePlan {
+export function planCreate(configured: Site, request: CreateRequest, documents: readonly DocumentEntry[]): CreatePlan {
+	// Collections under pages (Decision 7): a held collection's base is resolved from the listing.
+	const bases = heldBases(configured.collections, documents);
+	const site = withHeldBases(configured, bases);
 	const collection = own(site.collections, request.collection);
 	if (!collection) throw refused(400, 'bad-path', `No collection "${printable(request.collection)}" is declared.`);
 	if (collection.kind === 'settings') throw refused(400, 'not-allowed', 'Site Settings is always there, so it\'s never created.');
+	const unheld = own(bases, collection.name)?.problem;
+	if (unheld) throw refused(400, 'not-held', unheld);
 	if (request.path === '') throw refused(400, 'bad-name', NO_ADDRESS_MESSAGE);
 	if (request.path.split('/').includes(RESERVED_SLUG)) throw refused(400, 'index', INDEX_MESSAGE);
 
@@ -227,7 +233,7 @@ export function planCreate(site: Site, request: CreateRequest, documents: readon
 		throw refused(409, 'exists', url ? `There's already a page at ${url}.` : `There's already a ${collection.kind === 'shared' ? 'shared block' : 'document'} called "${where.path}".`);
 	}
 	if (url !== null) {
-		const collections = Object.values(site.collections).map(({ name, label, urlBase }) => ({ name, label, urlBase }));
+		const collections = Object.values(site.collections).map(({ name, label, urlBase, heldBy }) => ({ name, label, urlBase, heldBy }));
 		const problem = addressProblem(url, collection.name, collections, documents, site.codeRoutes);
 		if (problem) throw refused(problem.code === 'address-taken' ? 409 : 400, problem.code, problem.message);
 	}
@@ -252,6 +258,11 @@ export function planDelete(site: Site, request: DeleteRequest, documents: readon
 		throw refused(400, 'not-allowed', collection.urlBase === '/' ? 'Home can\'t be deleted.' : `${entry?.label ?? 'This page'} is the top of ${collection.label}, so it can't be deleted.`);
 	}
 	if (!entry) throw refused(404, 'not-found', `${collection.label}: no document "${printable(where.path)}".`);
+	// Collections under pages (Decision 12): a page that holds a collection stays, as Home does.
+	const held = entry.holds ? Object.values(site.collections).find((c) => c.name === entry.holds && c.heldBy === collection.name) : undefined;
+	if (held) {
+		throw refused(409, 'holds', holdsMessage(entry.label, held.label));
+	}
 	if (collection.kind === 'shared' && entry.usedOn?.length) {
 		const usedOn = entry.usedOn.map((u) => ({ ...u, title: documents.find((d) => d.collection === u.collection && d.path === u.path)?.label ?? u.path }));
 		throw refused(

package/src/editor/server/drafts-store.ts

@@ -12,7 +12,7 @@ import { SITE_SETTINGS_FILE, type ResolvedSite } from '../../config.ts';
 import { diskSource, listDocuments, readDocument, type ContentSource } from '../../content.ts';
 import type { AnyOpenedDocument, CreateRequest, CreateResponse, DeleteRequest, DeleteResponse, ListedDocument, MoveRequest, MoveResponse, OpenedDocument, ReplaceFileRequest, ReplaceFileResponse } from '../types.ts';
 import { confineOnDisk, createOnDisk, deleteOnDisk, planCreate, planDelete, target } from './create.ts';
-import { moveChanges, moveOnDisk, moveResponse, planMove, settingsWithoutRedirectFrom } from './move.ts';
+import { movesChanges, movesOnDisk, moveResponse, movesUnder, planMoves, settingsWithoutRedirectFrom, type ManyMoveRequest } from './move.ts';
 import { replaceChanges, replaceResponse } from './replace.ts';
 import { applyWrite, fileVersion, writeAtomic, type WriteContext, type WriteRequest, type WriteResponse } from './write.ts';
 
@@ -53,11 +53,19 @@ export interface DraftsStore {
 	/**
 	 * Change a document's address (pre-M7 item 8; move.ts has the rules, the same in both
 	 * stores): the document moves, every link and reference to it is rewritten, and Site
-	 * Settings gets a redirect from the old address. Local: on disk, the new file first and
-	 * the old one last. Live: every change is an autosave under this tab's locks, all going
-	 * out at the next Publish. Throws WriteRefused.
+	 * Settings gets a redirect from the old address. Collections under pages (Decision 9):
+	 * everything under a page moves with it, through `moveMany`. Throws WriteRefused.
 	 */
 	move(request: MoveRequest, context?: WriteContext): Promise<MoveResponse>;
+	/**
+	 * The many-move engine (collections under pages, Contracts): every document in the
+	 * request at its new path, and each held document whose holder's address changes,
+	 * checked as a whole, then applied all or nothing, each linking file rewritten once and
+	 * Site Settings written once and last, with every redirect and the caller's own edit.
+	 * Local: on disk, put back on a failure. Live: every lock taken up front, every change an
+	 * autosave, all rolled back on a failure, all going out at the next Publish. Throws WriteRefused.
+	 */
+	moveMany(request: ManyMoveRequest, context?: WriteContext): Promise<MoveResponse>;
 	/**
 	 * M6c G4 (Decision 9): Replace… on a file. Every link to `from`, in every document, points
 	 * at `to` (replace.ts has the rules, the same in both stores). Local: each file written
@@ -71,6 +79,15 @@ type Site = Pick<ResolvedSite, 'root' | 'collections' | 'blocks'>;
 
 /** The local store: the content files on disk. */
 export function localDraftsStore(site: Site): DraftsStore {
+	const moveMany = async (request: ManyMoveRequest): Promise<MoveResponse> => {
+		for (const m of request.moves) await confineOnDisk(site, target(site, m.collection, m.path).file);
+		const documents = await listDocuments(site);
+		const plans = planMoves(site, request.moves, documents);
+		const read = (file: string) => diskSource.readText(join(site.root, file));
+		const changes = await movesChanges(site, plans, documents, read, () => request.redirect !== false, request.editSettings);
+		await movesOnDisk(site, changes);
+		return moveResponse(plans, changes);
+	};
 	return {
 		async list() {
 			const entries = await listDocuments(site);
@@ -108,12 +125,10 @@ export function localDraftsStore(site: Site): DraftsStore {
 		async move(request) {
 			// The file first (a link out of the collection is refused before anything else), then the rules.
 			await confineOnDisk(site, target(site, request.collection, request.path).file);
-			const documents = await listDocuments(site);
-			const plan = planMove(site, request, documents);
-			const changes = await moveChanges(site, plan, documents, (file) => diskSource.readText(join(site.root, file)), true);
-			await moveOnDisk(site, plan, changes);
-			return moveResponse(site, plan, changes);
+			const moves = movesUnder(site, request, await listDocuments(site));
+			return moveMany({ moves, ...(request.redirect === false ? { redirect: false } : {}) });
 		},
+		moveMany,
 		async replaceFile(request) {
 			const changes = await replaceChanges(site, request, await listDocuments(site), (file) => diskSource.readText(join(site.root, file)));
 			// As a local move writes its relinked files: each confined and atomic, in listing order.