@heroiclands/package-build 23.12.7 → 23.13.0

package/types/engine/run-rows.d.mts

@@ -2,7 +2,7 @@
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"poetry"} kind - The construct.
+ * @property {"span"|"block"|"verse"} kind - The construct.
  * @property {string|null} lang - The language it is set in, as written: its
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
@@ -57,7 +57,7 @@ export type RecordRun = {
     /**
      * - The construct.
      */
-    kind: "span" | "block" | "poetry";
+    kind: "span" | "block" | "verse";
     /**
      * - The language it is set in, as written: its
      * own `lang=`, else the one the div or fence around it states.

package/types/engine/run-words.d.mts

@@ -1,18 +1,3 @@
-/**
- * A word as it is compared: NFC, lowercase, `’` read as `'`.
- *
- * @param {string} word - The word.
- * @returns {string} Its folded form.
- */
-export function foldWord(word: string): string;
-/**
- * The words a language note accepts of its own: its forms, and what its
- * plural rows, verb pattern and replacing suffixes derive from them.
- *
- * @param {Record<string, any>} data - The language note's `data`.
- * @returns {Set<string>} The words, folded.
- */
-export function lexiconWords(data: Record<string, any>): Set<string>;
 /**
  * The words of every name a language note registers under a tongue other than
  * `translation`.

package/types/engine/sql-tables.d.mts

@@ -65,10 +65,12 @@ export function findSqlBlocks(markdown: string): Array<{
  * @param {object} [opts.addressContext] - Address resolution context.
  * @param {"all"|"public"} [opts.audience] - Whether to exclude GM notes from
  *   local and dependency relations.
+ * @param {string} [opts.contentBase] - The directory the records' paths are
+ *   relative to, so a refused key is reported at its file and line.
  * @returns {Promise<{query: (sql: string) => Promise<object[]>,
  *   close: () => Promise<void>}>} The open database.
  */
-export function openNotesDatabase(records: object[], { dir, dependencies, addressContext, audience }?: {
+export function openNotesDatabase(records: object[], { dir, dependencies, addressContext, audience, contentBase }?: {
     dir?: string | undefined;
     dependencies?: {
         id: string;
@@ -76,6 +78,7 @@ export function openNotesDatabase(records: object[], { dir, dependencies, addres
     }[] | undefined;
     addressContext?: object | undefined;
     audience?: "all" | "public" | undefined;
+    contentBase?: string | undefined;
 }): Promise<{
     query: (sql: string) => Promise<object[]>;
     close: () => Promise<void>;

package/types/engine/text-maps.d.mts

@@ -126,7 +126,7 @@ export type MapRow = {
     /**
      * - Where the match must sit.
      */
-    at?: "end" | "start" | undefined;
+    at?: "start" | "end" | undefined;
 };
 /**
  * A map ready to apply.

package/types/engine/web-wikilinks.d.mts

@@ -19,7 +19,7 @@
  * Values are read from the *parsed* frontmatter, so a `[[` inside a YAML comment
  * is not a hit, and every hit can be named by the path a reader would look at.
  *
- * @param {unknown} fm - Parsed frontmatter, as `gray-matter` returns it.
+ * @param {unknown} fm - Parsed frontmatter, as `readMatter` returns it.
  * @returns {Array<{path: string, link: string}>} In reading order; `path` is the
  *   dotted key path of the offending value (`government.summary`, `aliases.1`).
  */

package/types/engine/word-forms.d.mts

@@ -0,0 +1,82 @@
+/**
+ * A word as it is compared: NFC, lowercase, `’` read as `'`.
+ *
+ * @param {string} word - The word.
+ * @returns {string} Its folded form.
+ */
+export function foldWord(word: string): string;
+/**
+ * Add a text's words to a set, each whole and each part of a compound.
+ *
+ * @param {Set<string>} set - The set.
+ * @param {string} text - A form or a name.
+ */
+export function addWords(set: Set<string>, text: string): void;
+/**
+ * One form a rule derives from a lexicon word.
+ *
+ * @typedef {object} DerivedForm
+ * @property {string} form - The form, folded.
+ * @property {Record<string, any>} word - The `data.words` entry it comes from.
+ */
+/**
+ * Every form the language's rules derive from its lexicon words, in
+ * `data.words` order, each once, leaving out a form that is a lexicon word.
+ *
+ * @param {Record<string, any>|undefined} data - The language note's `data`.
+ * @returns {DerivedForm[]} The forms.
+ */
+export function derivedForms(data: Record<string, any> | undefined): DerivedForm[];
+/**
+ * The words a language note accepts of its own: its forms, and what its rules
+ * derive from them (see {@link derivedForms}), each whole and each part of a
+ * compound.
+ *
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Set<string>} The words, folded.
+ */
+export function lexiconWords(data: Record<string, any>): Set<string>;
+/**
+ * A language's agreement rule, as derivation reads it.
+ */
+export type Agreement = {
+    /**
+     * - The class bases that agree.
+     */
+    classes: ReadonlySet<string>;
+    /**
+     * - The endings, folded, longest first.
+     */
+    endings: readonly string[];
+};
+/**
+ * A language's participle rule, as derivation reads it.
+ */
+export type Participles = {
+    /**
+     * - The root endings, folded, longest
+     * first.
+     */
+    root: readonly string[];
+    /**
+     * -
+     * The participle suffixes, folded.
+     */
+    suffixes: Array<{
+        suffix: string;
+        replaces: string | undefined;
+    }>;
+};
+/**
+ * One form a rule derives from a lexicon word.
+ */
+export type DerivedForm = {
+    /**
+     * - The form, folded.
+     */
+    form: string;
+    /**
+     * - The `data.words` entry it comes from.
+     */
+    word: Record<string, any>;
+};

package/types/release.d.mts

@@ -38,7 +38,7 @@
 export function packRelease({ stageDir, outDir, artifact, metadataDir, pdf, }?: {
     stageDir?: string | undefined;
     outDir?: string | undefined;
-    artifact?: "module" | "system" | undefined;
+    artifact?: "system" | "module" | undefined;
     metadataDir?: string | undefined;
     pdf?: boolean | undefined;
 }): Promise<{

package/engine/content-poetry.mjs

@@ -1,240 +0,0 @@
-/*
- * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
- * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
- *
- * This work is licensed under the GNU General Public License v3.0 (GPLv3).
- * You may copy, modify, and distribute it under the terms of that license.
- *
- * For full terms, see the LICENSE.md file in the project root or visit:
- * https://www.gnu.org/licenses/gpl-3.0.html
- *
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-/** The authored verse lines, excluding stanza separators. */
-export function verseLines(body) {
-    return String(body ?? "")
-        .split("\n")
-        .filter((line) => line.trim());
-}
-
-/**
- * The least-indented verse is level zero. Every two additional leading spaces
- * add one level; a leftover space is discarded and the level stops at eight.
- * Blank lines divide stanzas rather than contributing to the baseline.
- */
-export function poetryStanzas(body) {
-    const lines = String(body ?? "").split("\n");
-    const verses = verseLines(body);
-    if (!verses.length) return [];
-    const baseline = Math.min(...verses.map((line) => /^ */.exec(line)[0].length));
-    const stanzas = [];
-    let stanza = [];
-    for (const line of lines) {
-        if (!line.trim()) {
-            if (stanza.length) stanzas.push(stanza);
-            stanza = [];
-            continue;
-        }
-        const spaces = /^ */.exec(line)[0].length;
-        stanza.push({
-            text: line.slice(spaces).trimEnd(),
-            level: Math.min(8, Math.floor((spaces - baseline) / 2)),
-        });
-    }
-    if (stanza.length) stanzas.push(stanza);
-    return stanzas;
-}
-
-/** A verse is inline Markdown even when it starts with block syntax. */
-export function inlineVerse(text) {
-    return String(text)
-        .replace(/^(#{1,6}\s|>\s|[-+*]\s|:{1,2}\s|`{3,}|~{3,}|-{3,}\s*$)/, "\\$1")
-        .replace(/^(\d+)([.)])\s/, "$1\\$2 ");
-}
-
-/**
- * Keep stanzas as Markdown paragraphs and make every verse line a hard break.
- * The surrounding renderer still sees the entire note, so links and footnote
- * definitions remain in scope. The span carries the indent for each line.
- */
-export function poetryMarkdown(body) {
-    return poetryStanzas(body)
-        .map((stanza) =>
-            stanza
-                .map(
-                    ({ text, level }) =>
-                        `<span class="poetry-line${level ? ` i${level}` : ""}">${inlineVerse(text)}</span>`,
-                )
-                .join("  \n"),
-        )
-        .join("\n\n");
-}
-
-import MarkdownIt from "markdown-it";
-import { slugify } from "./content-slug.mjs";
-import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
-
-const structureParser = new MarkdownIt({ html: true });
-
-/**
- * The keys a poetry fence's attribute block takes. `lang`, `font` and `map`
- * are read by `scanRuns` in content-scripts.mjs; `dir`, and on the site
- * `data-pagefind-ignore`, are written by its rewrite of a fence set in one of
- * the faces, and reach the element as they are written.
- */
-export const POETRY_KEYS = Object.freeze([
-    "form",
-    "meter",
-    "rhyme",
-    "syllables",
-    "lang",
-    "font",
-    "map",
-    "dir",
-    "data-pagefind-ignore",
-]);
-
-/** Read poetry code fences; start/end are inclusive zero-based source lines.
- * @param {string} source - Authored Markdown.
- */
-export function scanPoetry(source) {
-    const lines = String(source ?? "").split("\n"),
-        blocks = [],
-        errors = [];
-    const literalLines = new Set();
-    for (const token of structureParser.parse(String(source ?? ""), {})) {
-        if (!token.map || !["blockquote_open", "html_block"].includes(token.type)) continue;
-        for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);
-    }
-    let opening = null;
-    for (let i = 0; i < lines.length; i++) {
-        if (literalLines.has(i)) continue;
-        const match = /^ *(`{3,}|~{3,})(.*)$/.exec(lines[i]);
-        if (opening) {
-            if (
-                match &&
-                match[1][0] === opening.fence[0] &&
-                match[1].length >= opening.fence.length &&
-                !match[2].trim()
-            ) {
-                if (opening.name === "poetry") {
-                    const body = lines.slice(opening.start + 1, i).join("\n");
-                    if (!body.trim())
-                        errors.push({
-                            line: opening.start + 1,
-                            column: 1,
-                            message: "poetry block is empty",
-                        });
-                    for (let n = opening.start + 1; n < i; n++) {
-                        const col = lines[n].indexOf("\t");
-                        if (col >= 0)
-                            errors.push({
-                                line: n + 1,
-                                column: col + 1,
-                                message: "tabs are not allowed in poetry",
-                            });
-                    }
-                    if (
-                        opening.attributes.syllables &&
-                        opening.attributes.syllables.split(",").length !== verseLines(body).length
-                    )
-                        errors.push({
-                            line: opening.start + 1,
-                            column: 1,
-                            message: `poetry syllables= gives ${opening.attributes.syllables.split(",").length} counts for ${verseLines(body).length} verse lines`,
-                        });
-                    blocks.push({ ...opening, end: i, body });
-                }
-                opening = null;
-            }
-            continue;
-        }
-        if (!match) continue;
-        const info = match[2].trim();
-        opening = {
-            start: i,
-            fence: match[1],
-            name: info.split(/\s/)[0],
-            attributes: {},
-            id: "",
-            classes: [],
-            indent: /^ */.exec(lines[i])[0],
-        };
-        if (opening.name !== "poetry") continue;
-        const raw = info.slice(6).trim();
-        const at = { line: i + 1, column: 1 };
-        if (raw && !/^\{[^}\n]*\}$/.test(raw)) {
-            errors.push({ ...at, message: "poetry attributes need {…} braces" });
-            continue;
-        }
-        const parsed = parseExtensionAttributes(raw ? raw.slice(1, -1) : "");
-        opening.id = parsed.id;
-        opening.classes = parsed.classes;
-        opening.attributes = parsed.values;
-        for (const message of [...parsed.problems, ...refusedAttributes(parsed.values)])
-            errors.push({ ...at, message });
-        for (const [key, value] of Object.entries(parsed.values)) {
-            if (!POETRY_KEYS.includes(key))
-                errors.push({ ...at, message: `${key}= is not a poetry attribute` });
-            else if (key === "syllables" && !/^[1-9]\d*(?:,[1-9]\d*)*$/.test(value))
-                errors.push({
-                    ...at,
-                    message: "poetry syllables= needs positive comma-separated counts",
-                });
-        }
-    }
-    if (opening?.name === "poetry")
-        errors.push({
-            line: opening.start + 1,
-            column: 1,
-            message: "poetry block needs a closing code fence",
-        });
-    return { blocks, errors };
-}
-
-/** Replace verse fences with HTML wrappers whose body remains inline Markdown.
- * @param {string} source - Authored Markdown.
- */
-export function renderPoetry(source) {
-    const { blocks, errors } = scanPoetry(source),
-        lines = String(source ?? "").split("\n"),
-        output = [];
-    let cursor = 0;
-    const escape = (value) =>
-        String(value)
-            .replace(/&/g, "&amp;")
-            .replace(/"/g, "&quot;")
-            .replace(/</g, "&lt;")
-            .replace(/>/g, "&gt;");
-    for (const block of blocks) {
-        output.push(...lines.slice(cursor, block.start));
-        const attrs = [`class="${escape(["poetry", ...block.classes].join(" "))}"`];
-        if (block.id) attrs.push(`id="${escape(slugify(block.id))}"`);
-        for (const [key, value] of Object.entries(block.attributes))
-            if (!refusedAttributes({ [key]: value }).length)
-                attrs.push(
-                    `${["lang", "dir", "data-pagefind-ignore"].includes(key) ? key : `data-${key}`}="${escape(value)}"`,
-                );
-        let indent = block.indent;
-        if (
-            indent.length >= 4 &&
-            !lines.slice(0, block.start).some((line) => /^ *(?:[-+*]|\d+[.)]) +/.test(line))
-        )
-            indent = "";
-        output.push(
-            "",
-            `${indent}<div ${attrs.join(" ")}>`,
-            "",
-            ...poetryMarkdown(block.body)
-                .split("\n")
-                .map((line) => (line ? indent + line : line)),
-            "",
-            `${indent}</div>`,
-            "",
-        );
-        cursor = block.end + 1;
-    }
-    output.push(...lines.slice(cursor));
-    return { markdown: output.join("\n"), errors };
-}

package/types/engine/content-poetry.d.mts

@@ -1,58 +0,0 @@
-/** The authored verse lines, excluding stanza separators. */
-export function verseLines(body: any): string[];
-/**
- * The least-indented verse is level zero. Every two additional leading spaces
- * add one level; a leftover space is discarded and the level stops at eight.
- * Blank lines divide stanzas rather than contributing to the baseline.
- */
-export function poetryStanzas(body: any): {
-    text: string;
-    level: number;
-}[][];
-/** A verse is inline Markdown even when it starts with block syntax. */
-export function inlineVerse(text: any): string;
-/**
- * Keep stanzas as Markdown paragraphs and make every verse line a hard break.
- * The surrounding renderer still sees the entire note, so links and footnote
- * definitions remain in scope. The span carries the indent for each line.
- */
-export function poetryMarkdown(body: any): string;
-/** Read poetry code fences; start/end are inclusive zero-based source lines.
- * @param {string} source - Authored Markdown.
- */
-export function scanPoetry(source: string): {
-    blocks: {
-        end: number;
-        body: string;
-        start: number;
-        fence: string;
-        name: string;
-        attributes: {};
-        id: string;
-        classes: never[];
-        indent: string;
-    }[];
-    errors: {
-        line: number;
-        column: number;
-        message: string;
-    }[];
-};
-/** Replace verse fences with HTML wrappers whose body remains inline Markdown.
- * @param {string} source - Authored Markdown.
- */
-export function renderPoetry(source: string): {
-    markdown: string;
-    errors: {
-        line: number;
-        column: number;
-        message: string;
-    }[];
-};
-/**
- * The keys a poetry fence's attribute block takes. `lang`, `font` and `map`
- * are read by `scanRuns` in content-scripts.mjs; `dir`, and on the site
- * `data-pagefind-ignore`, are written by its rewrite of a fence set in one of
- * the faces, and reach the element as they are written.
- */
-export const POETRY_KEYS: readonly string[];