@concordance-wiki/site 0.1.0

package/dist/build/entity-page.js

@@ -0,0 +1,782 @@
+import { pagePath } from "@concordance-wiki/core";
+import { formatDate, formatMessage, formatNumber, formatRelative } from "@concordance-wiki/i18n";
+import { byCodeUnit } from "../order.js";
+import { OPERATION_TYPE } from "../slots.js";
+import { DECISION_TYPE, decisionOf, yearBreadcrumbOf, yearSpaceOf } from "./decision.js";
+import { editHref, glyphNameOf, labelIn, message, relationLabel, spaceTitle, typeLabel, } from "./context.js";
+import { datedBreadcrumbOf, datedSpaceOf, isDatedSpace, MEETING_TYPE, meetingOf, } from "./meeting.js";
+import { citingPages, mentionsPanelOf } from "./mentions.js";
+import { exposedOperations, operationAttribute, unmatchedOperations, } from "./operations.js";
+import { groupingOf } from "./grouping.js";
+import { kindOf } from "./kinds.js";
+import { breadcrumbOf, spaceOf } from "./space.js";
+import { contractFileTarget, contractFragmentPath, entityHref, isContractUrl, relativeHref, searchFilterHref, } from "./paths.js";
+/** The properties every entity carries outside `attributes`, and the message that labels each. */
+const COMMON = ["application", "domain", "status"];
+function commonValue(entity, key) {
+    return entity[key];
+}
+/** The aliases are a field of the entity; every other key is one of its attributes. */
+function ownValue(entity, key) {
+    return key === "aliases" ? entity.aliases : entity.attributes[key];
+}
+function commonLabel(context, key) {
+    switch (key) {
+        case "application":
+            return message(context, "entity.application");
+        case "domain":
+            return message(context, "entity.domain");
+        case "status":
+            return message(context, "entity.status");
+    }
+}
+/** The label of an attribute in the site language: what the type or the common attributes declare, else the name itself. */
+export function attributeLabel(context, type, key) {
+    const { profile } = context;
+    const label = profile.types[type]?.attributes?.[key]?.label ?? profile.common_attributes?.[key]?.label;
+    return label === undefined ? key.replaceAll("_", " ") : labelIn(label, context.language);
+}
+/**
+ * The note a written value names, the way the pipeline resolves a reference: by its identifier
+ * as written, else by the identifier it takes within the source of the note
+ * (`roles/publication/reader` naming `specs/roles/publication/reader` from a note of `specs`);
+ * none for a value that is no identifier.
+ */
+function referencedOf(context, source, value) {
+    return context.entities.get(value) ?? context.entities.get(`${source}/${value}`);
+}
+/** A value of the frontmatter as the page shows it: scalars and lists of scalars, an identifier becoming a link titled as its note. */
+function valuesOf(context, page, source, value) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => valuesOf(context, page, source, item));
+    }
+    if (typeof value === "string") {
+        const target = referencedOf(context, source, value);
+        return [
+            target === undefined
+                ? { text: value }
+                : { text: target.title, href: entityHref(page, target.id) },
+        ];
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return [{ text: String(value) }];
+    }
+    return [];
+}
+/** The application or the domain of an entity as the page shows it: by the title the configuration gives it, leading to the results filtered on it. */
+function scopeValue(context, page, facet, id) {
+    const titles = facet === "application" ? context.names?.applications : context.names?.domains;
+    return { text: titles?.[id] ?? id, href: searchFilterHref(page, facet, id) };
+}
+/** One attribute of an entity as the page shows it, common or declared, labelled by the profile; none when the entity sets no value for it. */
+export function attributeOf(context, page, entity, key) {
+    const common = COMMON.find((candidate) => candidate === key);
+    const label = common === undefined ? attributeLabel(context, entity.type, key) : commonLabel(context, common);
+    const raw = common === undefined ? ownValue(entity, key) : commonValue(entity, common);
+    const values = (common === "application" || common === "domain") && typeof raw === "string"
+        ? [scopeValue(context, page, common, raw)]
+        : valuesOf(context, page, entity.source.name, raw);
+    return values.length === 0 ? undefined : { name: key, label, values };
+}
+function attributes(context, page, entity, keys) {
+    const seen = new Set();
+    const result = [];
+    for (const key of keys) {
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const attribute = attributeOf(context, page, entity, key);
+        if (attribute !== undefined)
+            result.push(attribute);
+    }
+    return result;
+}
+/** What `display.highlight` of the type names, in that order, when the entity has it. */
+export function highlightsOf(context, page, entity) {
+    return attributes(context, page, entity, [
+        ...(context.profile.types[entity.type]?.display?.highlight ?? []),
+    ]);
+}
+/** The keys of the frontmatter the profile declares, for the type or for every type. */
+function declaredKeys(context, type) {
+    const { profile } = context;
+    return {
+        typed: Object.keys(profile.types[type]?.attributes ?? {}),
+        common: Object.keys(profile.common_attributes ?? {}),
+    };
+}
+/**
+ * The side panel: the common properties, then the attributes the type declares in declaration
+ * order, then the other declared common attributes the note sets, in key order.
+ */
+export function panelOf(context, page, entity) {
+    const declared = declaredKeys(context, entity.type);
+    const set = Object.keys(entity.attributes).sort(byCodeUnit);
+    return attributes(context, page, entity, [
+        ...COMMON,
+        ...declared.typed.filter((key) => Object.hasOwn(entity.attributes, key)),
+        ...set.filter((key) => declared.common.includes(key)),
+    ]);
+}
+/** A value the profile knows nothing about, as written: scalars and their lists as text, anything nested as JSON. */
+function rawValuesOf(value) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => typeof item === "object" && item !== null
+            ? [{ text: JSON.stringify(item) }]
+            : rawValuesOf(item));
+    }
+    if (typeof value === "string") {
+        return [{ text: value }];
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return [{ text: String(value) }];
+    }
+    return value === null || value === undefined ? [] : [{ text: JSON.stringify(value) }];
+}
+/** The frontmatter keys the profile declares neither for the type nor for every type, kept as written, in key order. */
+export function othersOf(context, entity) {
+    const declared = declaredKeys(context, entity.type);
+    const others = [];
+    for (const key of Object.keys(entity.attributes).sort(byCodeUnit)) {
+        if (declared.typed.includes(key) || declared.common.includes(key))
+            continue;
+        const values = rawValuesOf(entity.attributes[key]);
+        if (values.length > 0)
+            others.push({ name: key, label: key, values });
+    }
+    return others;
+}
+/** The declaration of the type of an entity as the profile has it, labelled in the site language; none for an undeclared type. */
+export function declarationOf(context, type) {
+    const definition = context.profile.types[type];
+    if (definition === undefined)
+        return undefined;
+    const attributes = Object.entries(definition.attributes ?? {}).map(([name, attribute]) => ({
+        name,
+        label: attributeLabel(context, type, name),
+        type: attribute.type,
+        ...(attribute.target === undefined
+            ? {}
+            : { target: Array.isArray(attribute.target) ? attribute.target : [attribute.target] }),
+        ...(attribute.relation === undefined ? {} : { relation: attribute.relation }),
+        ...(attribute.values === undefined ? {} : { values: attribute.values }),
+    }));
+    const sections = Object.entries(definition.sections ?? {}).map(([key, section]) => ({
+        key,
+        heading: labelIn(section.heading, context.language),
+        parse: section.parse,
+        produces: section.produces,
+    }));
+    return {
+        type,
+        label: labelIn(definition.label, context.language),
+        group: definition.group,
+        ...(definition.glyph === undefined ? {} : { glyph: definition.glyph }),
+        attributes,
+        sections,
+        display: {
+            highlight: [...(definition.display?.highlight ?? [])],
+            neighboursOrder: [...(definition.display?.neighbours_order ?? [])],
+        },
+    };
+}
+/** A heading compared without regard to case, accents or surrounding and repeated whitespace, as the pipeline maps sections. */
+function foldHeading(heading) {
+    return heading.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().trim().replace(/\s+/g, " ");
+}
+/** The sections of the note, each mapped section of the type marked with its key when its heading matches, in any language or by the key itself. */
+export function sectionsOf(context, entity) {
+    const mapped = Object.entries(context.profile.types[entity.type]?.sections ?? {});
+    return (context.fragments.get(entity.id)?.sections ?? []).map((section) => {
+        if (section.heading === undefined)
+            return section;
+        const heading = foldHeading(section.heading);
+        const match = mapped.find(([key, definition]) => [key, ...Object.values({ ...definition.heading })].some((label) => foldHeading(label) === heading));
+        return match === undefined ? section : { ...section, key: match[0] };
+    });
+}
+/**
+ * How many one-hop neighbours an entity has: the other ends of the links touching it that are
+ * entities of the model, a link looping on its node counting for none, the way the displayed
+ * neighbourhood was computed before its truncation.
+ */
+export function neighbourCount(context, entity) {
+    const others = new Set();
+    for (const link of context.touching.get(entity.id) ?? []) {
+        const other = link.from === entity.id ? link.to : link.from;
+        if (other !== entity.id && context.entities.has(other))
+            others.add(other);
+    }
+    return others.size;
+}
+/**
+ * The neighbourhood of a page as the model ordered it; `weight` is the co-occurrence count when
+ * the model has one, and the relation reads from the page: a link pointing at the page takes the
+ * inverse label of its relation, so that the list names the nature of the link as the reader
+ * meets it. `total` counts every neighbour of the model, shown or not.
+ */
+export function neighbourhoodOf(context, page, entity) {
+    const counts = new Map((context.model.neighbours?.[entity.id] ?? []).map((neighbour) => [
+        neighbour.id,
+        neighbour.count,
+    ]));
+    const neighbours = (context.model.displayed_neighbourhood?.[entity.id] ?? []).map((neighbour) => {
+        const glyph = neighbour.kind === "keyword" ? undefined : glyphNameOf(context, neighbour.type);
+        return {
+            id: neighbour.id,
+            label: neighbour.title,
+            href: entityHref(page, neighbour.id),
+            typeLabel: neighbour.kind === "keyword"
+                ? message(context, "keyword.title")
+                : typeLabel(context, neighbour.type),
+            relation: relationLabel(context, neighbour.relation, {
+                inverse: neighbour.direction === "in",
+            }),
+            weight: counts.get(neighbour.id) ?? 1,
+            rank: neighbour.rank,
+            kind: neighbour.kind,
+            ...(glyph === undefined ? {} : { typeGlyph: glyph }),
+        };
+    });
+    const total = Math.max(neighbourCount(context, entity), neighbours.length);
+    return {
+        centre: entity.title,
+        neighbours,
+        total,
+        labels: neighbourhoodLabels(context, neighbours.length, total),
+    };
+}
+/** The strings of the map in the site language; the list heading is worded from the number listed, the pointer from the total. */
+export function neighbourhoodLabels(context, listed, total) {
+    return {
+        map: message(context, "neighbourhood.map"),
+        mapCaption: message(context, "neighbourhood.mapCaption"),
+        distance: message(context, "neighbourhood.distance"),
+        hop: formatMessage(context.catalogue, "neighbourhood.hop", { count: 1 }),
+        types: message(context, "related.types"),
+        existingPage: message(context, "neighbourhood.existingPage"),
+        noteless: message(context, "neighbourhood.noteless"),
+        neighbours: formatMessage(context.catalogue, "neighbourhood.list", { count: listed }),
+        textualEquivalent: message(context, "neighbourhood.textualEquivalent"),
+        capNote: message(context, "neighbourhood.capNote"),
+        noNeighbour: message(context, "neighbourhood.none"),
+        total: formatMessage(context.catalogue, "neighbourhood.total", { count: total }),
+        seeMentions: message(context, "neighbourhood.seeMentions"),
+    };
+}
+/**
+ * The files of an entity in its source, the note first: its path linked to its edit page on
+ * the forge when one is known, its call to action leading there, else to the contribution
+ * address of the project; none without either.
+ */
+export function sourcesOf(context, entity) {
+    const paths = [
+        entity.source.path,
+        ...(entity.representations ?? [])
+            .filter((representation) => representation.kind === undefined)
+            .map((representation) => representation.path),
+    ];
+    const forge = editHref(context, entity);
+    const edit = forge ?? context.contributeUrl;
+    return [...new Set(paths)].map((path) => ({
+        source: entity.source.name,
+        path,
+        ...(path === entity.source.path && forge !== undefined ? { href: forge } : {}),
+        ...(path === entity.source.path && edit !== undefined ? { editHref: edit } : {}),
+    }));
+}
+/** A row of the operations table: the page of the operation, its method and path when declared, how many pages cite it. */
+function operationItem(context, page, { entity: operation, name, documented }) {
+    const method = operationAttribute(operation, "method");
+    const path = operationAttribute(operation, "path");
+    return {
+        name,
+        title: operation.title,
+        ...(operation.summary === undefined ? {} : { summary: operation.summary }),
+        href: entityHref(page, operation.id),
+        documented,
+        ...(method === undefined ? {} : { method }),
+        ...(path === undefined ? {} : { path }),
+        callers: formatMessage(context.catalogue, "api.callers", {
+            count: citingPages(context, operation),
+        }),
+    };
+}
+/** The operations the contract import attached to the API, in model order, as the table lists them. */
+function operationsOf(context, page, entity) {
+    return exposedOperations(context, entity).map((operation) => operationItem(context, page, operation));
+}
+/** The operation notes the contract does not declare, as gap rows: named by the note, matched to nothing. */
+function unmatchedOf(context, page, entity) {
+    return unmatchedOperations(context, entity).map((note) => {
+        const id = note.attributes["operation_id"];
+        return operationItem(context, page, {
+            entity: note,
+            name: typeof id === "string" && id !== "" ? id : note.title,
+            documented: true,
+        });
+    });
+}
+/** When the contract last changed, relative to the build instant, worded in full and in short. */
+function importedOf(context, importedAt) {
+    const locale = context.locale ?? context.language;
+    const from = new Date(importedAt);
+    const to = new Date(context.model.build.at);
+    return {
+        date: importedAt.slice(0, 10),
+        label: formatMessage(context.catalogue, "api.imported", {
+            when: formatRelative(locale, from, to),
+        }),
+        short: formatRelative(locale, from, to, "short"),
+    };
+}
+/** The headings and notes of the contract side of the API page in the site language. */
+export function contractLabels(context) {
+    return {
+        operations: message(context, "api.operations"),
+        operationsLead: message(context, "api.operationsLead"),
+        gapsLead: message(context, "api.gapsLead"),
+        method: message(context, "api.colMethod"),
+        path: message(context, "api.colPath"),
+        operation: message(context, "api.colOperation"),
+        callersColumn: message(context, "api.colCallers"),
+        noOperation: message(context, "api.noOperation"),
+        withoutPage: message(context, "api.withoutPage"),
+        notInContract: message(context, "api.notInContract"),
+        unknownPath: message(context, "api.unknownPath"),
+        contract: message(context, "api.contract"),
+        download: message(context, "api.download"),
+        viewerNote: message(context, "api.viewerNote"),
+        fiveKeys: message(context, "api.fiveKeys"),
+        operationsFirst: message(context, "api.operationsFirst"),
+    };
+}
+/**
+ * The contract side of an `api` page, from the record the import left in the model; none without
+ * one. The block dates the contract by the last change of its file, as the ingest dates it, and
+ * by its import only for a contract fetched from a URL: the instant of the build says nothing
+ * about the contract.
+ */
+export function contractOf(context, page, entity) {
+    const record = context.model.build.contracts?.find((candidate) => candidate.api === entity.id);
+    if (record === undefined)
+        return undefined;
+    const { location } = record;
+    const unmatched = unmatchedOf(context, page, entity);
+    const importedAt = record.last_modified ?? record.imported_at;
+    return {
+        title: record.title,
+        version: record.version,
+        format: record.format,
+        importedAt,
+        imported: importedOf(context, importedAt),
+        location,
+        downloadHref: isContractUrl(location)
+            ? location
+            : relativeHref(page, contractFileTarget(entity.id, location)),
+        fragmentHref: relativeHref(page, contractFragmentPath(entity.id)),
+        operations: operationsOf(context, page, entity),
+        ...(unmatched.length === 0 ? {} : { unmatched }),
+        labels: contractLabels(context),
+    };
+}
+/** The properties a reader read from a file, as the page carries them: absent ones left out. */
+function readOf(document) {
+    return {
+        ...(document.size === undefined ? {} : { size: document.size }),
+        ...(document.author === undefined ? {} : { author: document.author }),
+        ...(document.date === undefined ? {} : { date: document.date }),
+        ...(document.pageCount === undefined ? {} : { pageCount: document.pageCount }),
+    };
+}
+function positionsOf(document) {
+    return document.pages.map(({ number, label, text, speaker }) => ({
+        number,
+        label,
+        text,
+        ...(speaker === undefined ? {} : { speaker }),
+    }));
+}
+/**
+ * The PDF twin of a converted file among the documents of its entity: the document copied where
+ * the file's preview is, a PDF being its own preview; none for a PDF, a transcript or a file
+ * whose PDF the build produced rather than read from the sources.
+ */
+export function previewTwinOf(document, documents) {
+    if (document.preview === undefined || document.preview === document.target)
+        return undefined;
+    return documents.find((candidate) => candidate.target === document.preview);
+}
+/** The check the converter reports a document it could not convert under. */
+export const CONVERSION_FAILED = "W-CONV-FAILED";
+/** The finding the build recorded for a document whose conversion failed, worded as its cause; none for a converted document. */
+export function conversionFailureOf(context, document) {
+    const finding = context.model.findings.find((candidate) => candidate.check === CONVERSION_FAILED &&
+        candidate.source === document.source &&
+        candidate.path === document.path);
+    return finding === undefined ? undefined : { cause: finding.message, check: finding.check };
+}
+/**
+ * The documents of the entity as its page offers them, from its fragment: the original file to
+ * download, the PDF to open, with the viewer bundles when the build produced them, and the
+ * extracted text of every position; nothing for an entity without a document. A converted file
+ * and the PDF kept next to it in the sources are one document, in the place of the original:
+ * the original to download, the PDF as its preview with what its reader read from it, the
+ * positions of the original, else those of the PDF when the original's reader gave none.
+ */
+export function documentsOf(context, page, entity, viewer) {
+    const documents = context.fragments.get(entity.id)?.documents ?? [];
+    const twins = new Set(documents.flatMap((document) => {
+        const twin = previewTwinOf(document, documents);
+        return twin === undefined ? [] : [twin];
+    }));
+    return documents
+        .filter((document) => !twins.has(document))
+        .map((document) => {
+        const twin = previewTwinOf(document, documents);
+        const own = positionsOf(document);
+        const fromTwin = own.length === 0 && twin !== undefined;
+        const failure = document.preview === undefined ? conversionFailureOf(context, document) : undefined;
+        return {
+            file: {
+                label: document.path.slice(document.path.lastIndexOf("/") + 1),
+                href: relativeHref(page, document.target),
+                format: document.format,
+            },
+            ...(document.preview === undefined
+                ? {}
+                : {
+                    preview: {
+                        href: relativeHref(page, document.preview),
+                        ...(viewer === undefined
+                            ? {}
+                            : {
+                                viewerHref: relativeHref(page, viewer.viewer),
+                                workerHref: relativeHref(page, viewer.worker),
+                            }),
+                        ...(twin === undefined ? {} : readOf(twin)),
+                    },
+                }),
+            unit: fromTwin ? twin.unit : document.unit,
+            positions: fromTwin ? positionsOf(twin) : own,
+            ...readOf(document),
+            ...(fromTwin ? { positionsFromPreview: true } : {}),
+            ...(failure === undefined ? {} : { previewFailure: failure }),
+        };
+    });
+}
+/**
+ * The document a page centres on: the first one with pages or slides, when no transcript
+ * accompanies it; a page with a transcript, or with notes alone, is not a document page.
+ */
+export function centralDocument(documents) {
+    return documents.some((document) => document.unit === "cue")
+        ? undefined
+        : documents.find((document) => document.unit !== "cue");
+}
+/** The type whose notes describe a document: their page is the document page even when the note leads. */
+export const DOCUMENT_TYPE = "document";
+/** Whether the file an entity stands for is a markdown note, the one that leads a group of twins when there is one. */
+export function leadsWithNote(entity) {
+    return entity.source.path.endsWith(".md");
+}
+/**
+ * How many positions a document has: the pages the conversion read, else the count the file or
+ * its preview states; none when nothing counted them. The positions of the PDF preview count
+ * for the original only through the count it states.
+ */
+export function pageCountOf(document) {
+    const converted = document.positions.length > 0 ? document.positions.length : undefined;
+    const own = document.positionsFromPreview === true ? document.pageCount : (converted ?? document.pageCount);
+    return own ?? converted ?? document.preview?.pageCount;
+}
+/**
+ * The line a document is folded behind under the note that leads its page: its file name,
+ * its kind, its page count when one is known. A transcript counts no page.
+ */
+export function documentSummary(context, document) {
+    return formatMessage(context.catalogue, "entity.alsoAvailable", {
+        name: document.file.label,
+        format: kindOf(context, document.file.format),
+        count: document.unit === "cue" ? 0 : (pageCountOf(document) ?? 0),
+    });
+}
+/** The documents with the line each is folded behind, for a page its note leads. */
+export function foldedDocuments(context, documents) {
+    return documents.map((document) => ({
+        ...document,
+        summary: documentSummary(context, document),
+    }));
+}
+/** A size in the unit that reads best, one decimal at most: "312 kB", "4.2 MB". */
+export function formatSize(locale, bytes) {
+    const [unit, divisor] = bytes >= 1_000_000_000
+        ? ["gigabyte", 1_000_000_000]
+        : bytes >= 1_000_000
+            ? ["megabyte", 1_000_000]
+            : ["kilobyte", 1_000];
+    return formatNumber(locale, bytes / divisor, {
+        style: "unit",
+        unit,
+        unitDisplay: "short",
+        maximumFractionDigits: 1,
+    });
+}
+/** The headings, notes and names of the document page in the site language. */
+export function documentPageLabels(context, pages = 0) {
+    return {
+        document: message(context, "document.view"),
+        extractedText: message(context, "document.extractedText"),
+        relatedNotes: message(context, "document.relatedNotes"),
+        views: message(context, "document.views"),
+        downloadOriginal: message(context, "document.download"),
+        pages: message(context, "document.pageCount"),
+        preview: message(context, "document.preview"),
+        openPdf: message(context, "document.openPdf"),
+        convertedNote: message(context, "document.convertedNote"),
+        originalNote: message(context, "document.originalNote"),
+        properties: message(context, "entity.attributes"),
+        type: message(context, "document.type"),
+        author: message(context, "document.author"),
+        pageCount: message(context, "document.pageCount"),
+        date: message(context, "document.date"),
+        dateNote: message(context, "document.dateNote"),
+        previewNote: message(context, "document.previewNote"),
+        noNote: message(context, "document.noNote"),
+        previewFailed: message(context, "document.previewFailed"),
+        textExtracted: message(context, "document.textExtracted"),
+        textMissing: message(context, "document.textMissing"),
+        whyFailed: message(context, "document.whyFailed"),
+        extractedTextOf: formatMessage(context.catalogue, "document.extractedTextOf", { count: pages }),
+        indexedNote: message(context, "document.indexedNote"),
+        representations: message(context, "document.representations"),
+        reportedNote: message(context, "document.reportedNote"),
+    };
+}
+/** The representations of a document whose conversion failed, the state of each written: the original, the preview that failed, the text read or not. */
+export function representationsOf(context, document) {
+    return [
+        {
+            label: `.${document.file.format}`,
+            state: message(context, "document.stateAvailable"),
+        },
+        {
+            label: `.pdf ${message(context, "document.rolePreview")}`,
+            state: message(context, "document.stateFailed"),
+            failed: true,
+        },
+        {
+            label: message(context, "document.textRepresentation"),
+            state: message(context, document.positions.length > 0 ? "document.stateExtracted" : "document.stateMissing"),
+        },
+    ];
+}
+/**
+ * What lays the page of an office document out: the kind of the file from its extension, its
+ * page count (what the conversion found, else what the file states), its size, its date (the
+ * one the file states, else the last change in the repository) and its author; none for an
+ * entity that is not a document page. A count or a size the original does not give is read
+ * from its PDF preview, and the page says so.
+ */
+export function documentPageOf(context, entity, documents) {
+    const document = centralDocument(documents);
+    if (document === undefined)
+        return undefined;
+    const locale = context.locale ?? context.language;
+    const preview = document.preview;
+    const converted = document.positions.length > 0 ? document.positions.length : undefined;
+    const own = document.positionsFromPreview === true ? document.pageCount : (converted ?? document.pageCount);
+    const pages = pageCountOf(document) ?? 0;
+    const size = document.size ?? preview?.size;
+    const fromPreview = (own === undefined && pages !== 0) || (document.size === undefined && size !== undefined);
+    const fileDate = document.date ?? preview?.date;
+    const iso = fileDate ?? entity.source.last_modified;
+    const author = document.author ?? preview?.author;
+    return {
+        kind: kindOf(context, document.file.format),
+        ...(pages === 0
+            ? {}
+            : {
+                pages,
+                pagesLabel: formatMessage(context.catalogue, "document.pages", { count: pages }),
+            }),
+        ...(size === undefined ? {} : { size: formatSize(locale, size) }),
+        ...(iso === undefined
+            ? {}
+            : {
+                date: {
+                    date: iso.slice(0, 10),
+                    label: formatDate(locale, new Date(iso), "long"),
+                    fromFile: fileDate !== undefined,
+                },
+            }),
+        ...(author === undefined ? {} : { author }),
+        ...(fromPreview ? { fromPreview } : {}),
+        ...(document.previewFailure === undefined
+            ? {}
+            : {
+                previewFailure: document.previewFailure,
+                representations: representationsOf(context, document),
+            }),
+        labels: documentPageLabels(context, pages),
+    };
+}
+/**
+ * When the note last changed, relative to the build instant so that two builds of the same
+ * corpus agree, worded in full and in short for the line of a narrow page; none without a git date.
+ */
+export function changedOf(context, entity) {
+    const changed = entity.source.last_modified;
+    if (changed === undefined)
+        return undefined;
+    const locale = context.locale ?? context.language;
+    const from = new Date(changed);
+    const to = new Date(context.model.build.at);
+    return {
+        date: changed.slice(0, 10),
+        label: formatMessage(context.catalogue, "entity.changed", {
+            when: formatRelative(locale, from, to),
+        }),
+        short: formatRelative(locale, from, to, "short"),
+    };
+}
+/** How many pages the map draws: the neighbours listed, never the total the model holds beyond them. */
+export function neighbourPages(neighbourhood) {
+    return neighbourhood.neighbours.length;
+}
+/** The headings and notes of the page in the site language, the counts of neighbours and of declared keys worded. */
+export function entityPageLabels(context, neighbours, declared, source) {
+    return {
+        properties: message(context, "entity.attributes"),
+        declaredAtTop: formatMessage(context.catalogue, "entity.declaredAtTop", { count: declared }),
+        otherAttributes: message(context, "entity.otherAttributes"),
+        onThisPage: message(context, "entity.onThisPage"),
+        spaceTree: message(context, "entity.spaceTree"),
+        breadcrumb: message(context, "entity.breadcrumb"),
+        correction: message(context, "entity.correction"),
+        edit: message(context, "entity.edit"),
+        seeNeighbourhood: message(context, "entity.seeNeighbourhood"),
+        neighbourPages: formatMessage(context.catalogue, "entity.neighbourPages", {
+            count: neighbours,
+        }),
+        legendWritten: message(context, "entity.legendWritten"),
+        legendRecognised: message(context, "entity.legendRecognised"),
+        legendKeyword: message(context, "entity.legendKeyword"),
+        imageNote: message(context, "entity.imageNote"),
+        inSpace: formatMessage(context.catalogue, "entity.inSpace", {
+            space: spaceTitle(context, source),
+        }),
+        editShort: message(context, "entity.editShort"),
+    };
+}
+function treeShapeOf(context, entity, dated) {
+    if (!dated || !isDatedSpace(context, entity.source.name))
+        return "folders";
+    return entity.type === DECISION_TYPE ? "years" : "months";
+}
+function spaceByShape(context, page, entity, shape) {
+    switch (shape) {
+        case "folders":
+            return spaceOf(context, page, entity);
+        case "months":
+            return datedSpaceOf(context, page, entity);
+        case "years":
+            return yearSpaceOf(context, page, entity);
+    }
+}
+function breadcrumbByShape(context, page, entity, shape) {
+    switch (shape) {
+        case "folders":
+            return breadcrumbOf(context, page, entity);
+        case "months":
+            return datedBreadcrumbOf(context, page, entity);
+        case "years":
+            return yearBreadcrumbOf(context, page, entity);
+    }
+}
+/**
+ * The view model of the page of a typed entity, its sections and documents read from its
+ * fragment. A meeting, a document or a decision carries what its own template lays out on top:
+ * when every note of its space is dated, the tree is drawn by year and month and the breadcrumb
+ * names the month, by year alone for a decision.
+ */
+/** The check the contract import reports an `api` whose declared contract it could not read under. */
+export const CONTRACT_UNREACHABLE = "W-CONTRACT-UNREACHABLE";
+/**
+ * The notice of an `api` whose declared contract the build could not read, from the finding it
+ * recorded for the entity: the fact, what remains, the declared address as an exit when it is
+ * one, the finding behind its disclosure; none for any other page.
+ */
+export function contractNoticeOf(context, entity) {
+    const finding = context.model.findings.find((candidate) => candidate.check === CONTRACT_UNREACHABLE && candidate.entity === entity.id);
+    if (finding === undefined)
+        return undefined;
+    const location = entity.attributes["contract"];
+    const exits = typeof location === "string" && isContractUrl(location)
+        ? [{ label: message(context, "api.openContract"), href: location }]
+        : [];
+    return {
+        lead: message(context, "api.contractUnreachable"),
+        detail: message(context, "api.contractUnreachableDetail"),
+        exits,
+        finding: {
+            label: message(context, "document.whyFailed"),
+            cause: finding.message,
+            check: finding.check,
+        },
+    };
+}
+export function entityPageOf(context, entity, options = {}) {
+    const page = pagePath(entity.id);
+    const read = documentsOf(context, page, entity, options.viewer);
+    // The template follows the lead: a note keeps the template of its type and folds its twins
+    // under the article; a document without a note, or a note describing one, gets the document page.
+    const leads = leadsWithNote(entity) && entity.type !== DOCUMENT_TYPE;
+    const document = leads ? undefined : documentPageOf(context, entity, read);
+    const documents = leads && entity.type !== MEETING_TYPE ? foldedDocuments(context, read) : read;
+    const contract = contractOf(context, page, entity);
+    const notice = contract === undefined ? contractNoticeOf(context, entity) : undefined;
+    const declaration = declarationOf(context, entity.type);
+    const otherAttributes = othersOf(context, entity);
+    const changed = changedOf(context, entity);
+    const neighbours = neighbourhoodOf(context, page, entity);
+    const attributes = panelOf(context, page, entity);
+    const grouping = groupingOf(context, entity);
+    const meeting = entity.type === MEETING_TYPE ? meetingOf(context, page, entity, documents) : undefined;
+    const decision = entity.type === DECISION_TYPE
+        ? decisionOf(context, page, entity, (session) => documentsOf(context, pagePath(session.id), session, options.viewer))
+        : undefined;
+    const shape = treeShapeOf(context, entity, meeting !== undefined || document !== undefined || decision !== undefined);
+    // On an interface the operations lead: the served slice of the mentions starts with them.
+    const mentions = mentionsPanelOf(context, page, entity, options.mentionsInline, contract === undefined ? undefined : OPERATION_TYPE);
+    return {
+        entity: {
+            id: entity.id,
+            type: entity.type,
+            typeLabel: typeLabel(context, entity.type),
+            title: entity.title,
+            locale: entity.locale,
+        },
+        typeHref: searchFilterHref(page, "type", entity.type),
+        ...(declaration === undefined ? {} : { declaration }),
+        space: spaceByShape(context, page, entity, shape),
+        breadcrumb: breadcrumbByShape(context, page, entity, shape),
+        ...(changed === undefined ? {} : { changed }),
+        highlights: highlightsOf(context, page, entity),
+        sections: sectionsOf(context, entity),
+        attributes,
+        ...(otherAttributes.length === 0 ? {} : { otherAttributes }),
+        labels: entityPageLabels(context, neighbourPages(neighbours), attributes.length, entity.source.name),
+        neighbours,
+        mentions,
+        sources: sourcesOf(context, entity),
+        ...(documents.length === 0 ? {} : { documents }),
+        ...(grouping === undefined ? {} : { grouping }),
+        ...(contract === undefined ? {} : { contract }),
+        ...(meeting === undefined ? {} : { meeting }),
+        ...(document === undefined ? {} : { document }),
+        ...(decision === undefined ? {} : { decision }),
+        ...(notice === undefined ? {} : { notice }),
+    };
+}
+//# sourceMappingURL=entity-page.js.map