@heroiclands/package-build 23.7.0 → 23.8.0

package/engine/language-data.mjs

@@ -25,6 +25,11 @@
  *   `data.tongues`, `translation` apart: `exonym:vylari` is declared by
  *   `exonym:<tongue>`;
  * - an edge stands once in `data.sounds.edges`;
+ * - a sound stands once in each mutation of `data.sounds.mutations`;
+ * - a cluster stands in one group of `data.sounds.clusters.groups`, and a
+ *   language stating groups states no `innerCluster` edge;
+ * - every vowel `data.sounds.syllables.harmony.partners` keys is a vowel of
+ *   the harmony, and every partner one of its `front` vowels;
  * - every Address in `data.scope` resolves, and every type it names is a note
  *   type;
  * - every language a cognate's `forms` names is a language note;
@@ -32,7 +37,15 @@
  * - a sound-change set's name stands once in the note, a step's label once
  *   in its set, and its `from` and `to` name language notes;
  * - a frame's classes are bases of the master word classes;
- * - a calling-name closing states a `form` or `doubled: true`, not both.
+ * - a calling-name closing states a `form` or `doubled: true`, not both;
+ * - a form stands once in `data.older`;
+ * - the mutation `data.negation` names is one of `data.sounds.mutations`;
+ * - in `data.naming`, a class of name has one shape, which states its
+ *   syllables, its consonants per vowel or both, each range's `min` no
+ *   higher than its `max`; an edge stands once for each class of name; a kind
+ *   of name has one set of draws; and a held-from row takes `elements` only
+ *   where it takes an `element`, and is clipped or given a genitive only
+ *   where it takes a name.
  *
  * @module
  */
@@ -43,6 +56,9 @@ import { addressKeyOf } from "./culture-reach.mjs";
 import { AddressEntries } from "./address-values.mjs";
 import { isAddressTuple, renderAddress } from "./address.mjs";
 import {
+    ANY_NAME,
+    HELD_NAMES,
+    HELD_TAKES,
     LANGUAGE_DATA_KEYS,
     RESERVED_TONGUE,
     SCOPE_KINDS,
@@ -287,6 +303,80 @@ export function checkLanguageData(note, { index, types } = {}) {
         else edgeAt.set(row.edge, i);
     });
 
+    if (isMap(sounds.clusters) && Array.isArray(sounds.clusters.groups))
+        listOf(sounds.edges).forEach((row, i) => {
+            if (!isMap(row) || row.edge !== "innerCluster") return;
+            findings.push(
+                finding(
+                    ["data", "sounds", "edges", i, "edge"],
+                    "error",
+                    "`data.sounds.clusters.groups` states the clusters inside a word, so no " +
+                        "`innerCluster` edge does",
+                ),
+            );
+        });
+    const clusterAt = new Map();
+    listOf(sounds.clusters?.groups).forEach((group, i) => {
+        if (!isMap(group)) return;
+        listOf(group.clusters).forEach((cluster, j) => {
+            if (typeof cluster !== "string") return;
+            if (clusterAt.has(cluster))
+                findings.push(
+                    finding(
+                        ["data", "sounds", "clusters", "groups", i, "clusters", j],
+                        "error",
+                        `the cluster \`${cluster}\` stands twice, first in ` +
+                            `\`data.sounds.clusters.groups[${clusterAt.get(cluster)}]\``,
+                    ),
+                );
+            else clusterAt.set(cluster, i);
+        });
+    });
+
+    const mutationAt = new Map();
+    listOf(sounds.mutations).forEach((row, i) => {
+        if (!isMap(row) || typeof row.mutation !== "string" || typeof row.sound !== "string")
+            return;
+        const key = JSON.stringify([row.mutation, row.sound]);
+        if (mutationAt.has(key))
+            findings.push(
+                finding(
+                    ["data", "sounds", "mutations", i, "sound"],
+                    "error",
+                    `the sound \`${row.sound}\` stands twice in the mutation \`${row.mutation}\`, ` +
+                        `first at \`data.sounds.mutations[${mutationAt.get(key)}]\``,
+                ),
+            );
+        else mutationAt.set(key, i);
+    });
+
+    const harmony = isMap(sounds.syllables?.harmony) ? sounds.syllables.harmony : {};
+    if (isMap(harmony.partners)) {
+        const front = new Set(listOf(harmony.front));
+        const vowels = new Set([...listOf(harmony.back), ...front, ...listOf(harmony.neutral)]);
+        for (const [vowel, partner] of Object.entries(harmony.partners)) {
+            const path = ["data", "sounds", "syllables", "harmony", "partners", vowel];
+            if (!vowels.has(vowel))
+                findings.push(
+                    finding(
+                        path,
+                        "error",
+                        `\`${vowel}\` is not a vowel of \`data.sounds.syllables.harmony\``,
+                        true,
+                    ),
+                );
+            else if (typeof partner === "string" && !front.has(partner))
+                findings.push(
+                    finding(
+                        path,
+                        "error",
+                        `the partner \`${partner}\` of \`${vowel}\` is not one of the harmony's ` +
+                            "`front` vowels",
+                    ),
+                );
+        }
+    }
+
     listOf(sounds.frames).forEach((row, i) => {
         if (!isMap(row)) return;
         listOf(row.class).forEach((base, j) => {
@@ -351,6 +441,151 @@ export function checkLanguageData(note, { index, types } = {}) {
             );
     });
 
+    // ── Older forms and negation ─────────────────────────────────────────────
+    const olderAt = new Map();
+    listOf(data.older).forEach((row, i) => {
+        if (!isMap(row) || typeof row.form !== "string") return;
+        if (olderAt.has(row.form))
+            findings.push(
+                finding(
+                    ["data", "older", i, "form"],
+                    "error",
+                    `the form \`${row.form}\` stands twice, first at \`data.older[${olderAt.get(row.form)}]\``,
+                ),
+            );
+        else olderAt.set(row.form, i);
+    });
+    const negation = isMap(data.negation) ? data.negation : {};
+    if (typeof negation.mutation === "string") {
+        const named = new Set(
+            listOf(sounds.mutations)
+                .filter((row) => isMap(row) && typeof row.mutation === "string")
+                .map((row) => row.mutation),
+        );
+        if (!named.has(negation.mutation))
+            findings.push(
+                finding(
+                    ["data", "negation", "mutation"],
+                    "error",
+                    `the mutation \`${negation.mutation}\` is not one of \`data.sounds.mutations\``,
+                ),
+            );
+    }
+
+    // ── Naming ───────────────────────────────────────────────────────────────
+    const naming = isMap(data.naming) ? data.naming : {};
+    /**
+     * A finding at the second of two entries sharing a key.
+     *
+     * @param {string} list - The list under `data.naming`.
+     * @param {(row: object) => string|undefined} keyOf - The entry's key.
+     * @param {(row: object, first: number) => [Array<string|number>, string]} report
+     *   - Where the second sits, relative to its entry, and what is said.
+     */
+    const once = (list, keyOf, report) => {
+        const seen = new Map();
+        listOf(naming[list]).forEach((row, i) => {
+            if (!isMap(row)) return;
+            const key = keyOf(row);
+            if (key === undefined) return;
+            if (seen.has(key)) {
+                const [rest, message] = report(row, seen.get(key));
+                findings.push(finding(["data", "naming", list, i, ...rest], "error", message));
+            } else seen.set(key, i);
+        });
+    };
+    once(
+        "shapes",
+        (row) => (typeof row.of === "string" ? row.of : undefined),
+        (row, first) => [
+            ["of"],
+            `the class of name \`${row.of}\` has its shape stated twice, first at ` +
+                `\`data.naming.shapes[${first}]\``,
+        ],
+    );
+    once(
+        "edges",
+        (row) =>
+            typeof row.edge === "string" ?
+                JSON.stringify([row.edge, row.of ?? ANY_NAME])
+            :   undefined,
+        (row, first) => [
+            ["edge"],
+            `the edge \`${row.edge}\` of \`${row.of ?? ANY_NAME}\` stands twice, first at ` +
+                `\`data.naming.edges[${first}]\``,
+        ],
+    );
+    once(
+        "draws",
+        (row) => (typeof row.kind === "string" ? row.kind : undefined),
+        (row, first) => [
+            ["kind"],
+            `the kind \`${row.kind}\` has its draws stated twice, first at ` +
+                `\`data.naming.draws[${first}]\``,
+        ],
+    );
+    listOf(naming.shapes).forEach((row, i) => {
+        if (!isMap(row)) return;
+        const at = (...rest) => ["data", "naming", "shapes", i, ...rest];
+        if (row.syllables == null && row.perVowel == null)
+            findings.push(
+                finding(
+                    at(),
+                    "error",
+                    `\`data.naming.shapes[${i}]\` states neither \`syllables\` nor \`perVowel\``,
+                ),
+            );
+        for (const key of ["syllables", "perVowel"]) {
+            const range = row[key];
+            if (!isMap(range) || typeof range.min !== "number" || typeof range.max !== "number")
+                continue;
+            if (range.min > range.max)
+                findings.push(
+                    finding(
+                        at(key),
+                        "error",
+                        `\`data.naming.shapes[${i}].${key}\` runs from ${range.min} to ${range.max}; ` +
+                            "its `min` is above its `max`",
+                    ),
+                );
+        }
+    });
+    listOf(naming.heldFrom).forEach((row, i) => {
+        if (!isMap(row) || !HELD_TAKES.includes(row.takes)) return;
+        const at = (...rest) => ["data", "naming", "heldFrom", i, ...rest];
+        const label = `\`data.naming.heldFrom[${i}]\``;
+        if (row.takes === "element") {
+            if (!listOf(row.elements).length)
+                findings.push(
+                    finding(
+                        at(),
+                        "error",
+                        `${label} takes an \`element\` and names no \`elements\``,
+                    ),
+                );
+        } else if (row.elements != null)
+            findings.push(
+                finding(
+                    at("elements"),
+                    "error",
+                    `\`elements\` lists what a place takes first, and ${label} takes a ` +
+                        `\`${row.takes}\``,
+                    true,
+                ),
+            );
+        if (!HELD_NAMES.includes(row.takes))
+            for (const key of ["clip", "genitive"])
+                if (row[key] != null)
+                    findings.push(
+                        finding(
+                            at(key),
+                            "error",
+                            `\`${key}\` shapes a name, and ${label} takes a \`${row.takes}\``,
+                            true,
+                        ),
+                    );
+    });
+
     // ── Scope ────────────────────────────────────────────────────────────────
     const scope = isMap(data.scope) ? data.scope : {};
     for (const kind of SCOPE_KINDS) {

package/engine/language-rows.mjs

@@ -33,6 +33,13 @@
  *   `elements` and `roots` — one row per entry, the list keys always lists;
  * - `scope` — one row per value, with the `kind` of `data.scope` it is under;
  * - `clusters` — one row per language stating `data.sounds.clusters`;
+ * - `cluster_groups` and `mutations` — one row per entry of
+ *   `data.sounds.clusters.groups` and `data.sounds.mutations`;
+ * - `older` — one row per `data.older` entry;
+ * - `negation` — one row per language stating `data.negation`;
+ * - `name_shapes`, `name_edges`, `name_draws` and `held_from` — one row per
+ *   entry of the lists of `data.naming`, and `near_names` one per worked
+ *   near name, with the language's `min_syllables`;
  * - `cognates` — one row per form of each set, with the set's `gloss`.
  *
  * @module
@@ -40,7 +47,9 @@
 
 import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
 import {
+    ANY_NAME,
     CALLING_CLOSING_KEYS,
+    CLUSTER_GROUP_KEYS,
     EDGE_KEYS,
     ELEMENT_KEYS,
     FINAL_KEYS,
@@ -48,6 +57,8 @@ import {
     JOIN_KEYS,
     LETTER_KEYS,
     MARK_KEYS,
+    MUTATION_KEYS,
+    OLDER_KEYS,
     READ_PAST_KEYS,
     REGISTER_KEYS,
     RETIRED_KEYS,
@@ -86,6 +97,38 @@ export const LETTER_COLUMNS = Object.freeze([...IDENTITY, ...LETTER_KEYS]);
 export const EDGE_COLUMNS = Object.freeze([...IDENTITY, ...EDGE_KEYS]);
 /** Every column of the `clusters` relation, in order. */
 export const CLUSTER_COLUMNS = Object.freeze(["language", "max"]);
+/** Every column of the `cluster_groups` relation, in order. */
+export const CLUSTER_GROUP_COLUMNS = Object.freeze([...IDENTITY, ...CLUSTER_GROUP_KEYS]);
+/** Every column of the `mutations` relation, in order. */
+export const MUTATION_COLUMNS = Object.freeze([...IDENTITY, ...MUTATION_KEYS]);
+/** Every column of the `older` relation, in order. */
+export const OLDER_COLUMNS = Object.freeze([...IDENTITY, ...OLDER_KEYS]);
+/** Every column of the `name_shapes` relation, in order. */
+export const NAME_SHAPE_COLUMNS = Object.freeze([
+    ...IDENTITY,
+    "of",
+    "syllables_min",
+    "syllables_max",
+    "per_vowel_min",
+    "per_vowel_max",
+]);
+/** Every column of the `name_edges` relation, in order. */
+export const NAME_EDGE_COLUMNS = Object.freeze([...IDENTITY, "edge", "sounds", "vowel", "of"]);
+/** Every column of the `name_draws` relation, in order. */
+export const NAME_DRAW_COLUMNS = Object.freeze([...IDENTITY, "kind", "elements"]);
+/** Every column of the `held_from` relation, in order. */
+export const HELD_FROM_COLUMNS = Object.freeze([
+    ...IDENTITY,
+    "source",
+    "takes",
+    "clip",
+    "genitive",
+    "elements",
+]);
+/** Every column of the `near_names` relation, in order. */
+export const NEAR_NAME_COLUMNS = Object.freeze([...IDENTITY, "near", "given", "min_syllables"]);
+/** Every column of the `negation` relation, in order: one row per language. */
+export const NEGATION_COLUMNS = Object.freeze(["language", "particle", "mutation"]);
 /** Every column of the `stress` relation, in order. */
 export const STRESS_COLUMNS = Object.freeze(["language", "stress"]);
 /** Every column of the `finals` relation, in order. */
@@ -106,6 +149,7 @@ export const SYLLABLE_COLUMNS = Object.freeze([
     "harmony_front",
     "harmony_neutral",
     "harmony_neutralAs",
+    "harmony_partners",
 ]);
 /** Every column of the `joining` relation, in order. */
 export const JOINING_COLUMNS = Object.freeze([...IDENTITY, ...JOINING_KEYS]);
@@ -132,6 +176,7 @@ export const SOUND_CHANGE_COLUMNS = Object.freeze([
     "name",
     "from_language",
     "to_language",
+    "takes",
     "step_position",
     ...SOUND_CHANGE_STEP_KEYS,
 ]);
@@ -174,6 +219,21 @@ export const LANGUAGE_COLUMN_TYPES = Object.freeze({
     letters: { position: "BIGINT", letters: LIST, tongue: LIST },
     edges: { position: "BIGINT", sounds: LIST },
     clusters: { max: "BIGINT" },
+    cluster_groups: { position: "BIGINT", clusters: LIST },
+    mutations: { position: "BIGINT" },
+    older: { position: "BIGINT" },
+    negation: {},
+    name_shapes: {
+        position: "BIGINT",
+        syllables_min: "BIGINT",
+        syllables_max: "BIGINT",
+        per_vowel_min: "DOUBLE",
+        per_vowel_max: "DOUBLE",
+    },
+    name_edges: { position: "BIGINT", sounds: LIST, vowel: "BOOLEAN" },
+    name_draws: { position: "BIGINT", elements: LIST },
+    held_from: { position: "BIGINT", genitive: LIST, elements: LIST },
+    near_names: { position: "BIGINT", min_syllables: "BIGINT" },
     stress: {},
     finals: { position: "BIGINT" },
     syllables: {
@@ -188,6 +248,7 @@ export const LANGUAGE_COLUMN_TYPES = Object.freeze({
         harmony_back: LIST,
         harmony_front: LIST,
         harmony_neutral: LIST,
+        harmony_partners: "STRUCT(vowel VARCHAR, partner VARCHAR)[]",
     },
     joining: { position: "BIGINT", first: LIST, second: LIST },
     joins: { position: "BIGINT", letters: LIST },
@@ -470,6 +531,159 @@ export function clusterRows(records) {
     return rows;
 }
 
+/**
+ * The `cluster_groups` rows: one per `data.sounds.clusters.groups` entry,
+ * `clusters` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function clusterGroupRows(records) {
+    return listRows(records, (data) => soundsOf(data).clusters?.groups, CLUSTER_GROUP_KEYS, {
+        lists: ["clusters"],
+    });
+}
+
+/**
+ * The `mutations` rows: one per `data.sounds.mutations` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function mutationRows(records) {
+    return listRows(records, (data) => soundsOf(data).mutations, MUTATION_KEYS);
+}
+
+/**
+ * The `older` rows: one per `data.older` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function olderRows(records) {
+    return listRows(records, (data) => data.older, OLDER_KEYS);
+}
+
+/**
+ * The `negation` rows: one per language stating `data.negation`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function negationRows(records) {
+    const rows = [];
+    for (const [language, record] of languagesOf(records)) {
+        const negation = record.data?.negation;
+        if (isMap(negation))
+            rows.push({
+                language,
+                particle: negation.particle ?? null,
+                mutation: negation.mutation ?? null,
+            });
+    }
+    return rows;
+}
+
+/** A language's `data.naming`, or an empty map. */
+const namingOf = (data) => (isMap(data.naming) ? data.naming : {});
+
+/** A range's bound, or `null`. */
+const bound = (range, key) => (isMap(range) && typeof range[key] === "number" ? range[key] : null);
+
+/**
+ * The `name_shapes` rows: one per `data.naming.shapes` entry, each range as
+ * its two bounds.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameShapeRows(records) {
+    const rows = [];
+    for (const [language, record] of languagesOf(records)) {
+        const shapes = namingOf(isMap(record.data) ? record.data : {}).shapes;
+        if (!Array.isArray(shapes)) continue;
+        shapes.forEach((shape, position) => {
+            if (!isMap(shape)) return;
+            rows.push({
+                language,
+                position,
+                of: shape.of ?? null,
+                syllables_min: bound(shape.syllables, "min"),
+                syllables_max: bound(shape.syllables, "max"),
+                per_vowel_min: bound(shape.perVowel, "min"),
+                per_vowel_max: bound(shape.perVowel, "max"),
+            });
+        });
+    }
+    return rows;
+}
+
+/**
+ * The `name_edges` rows: one per `data.naming.edges` entry, `sounds` a list,
+ * `vowel` `false` and `of` `name` where unstated.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameEdgeRows(records) {
+    return listRows(records, (data) => namingOf(data).edges, ["edge", "sounds", "vowel", "of"], {
+        lists: ["sounds"],
+    }).map((row) => ({ ...row, vowel: row.vowel === true, of: row.of ?? ANY_NAME }));
+}
+
+/**
+ * The `name_draws` rows: one per `data.naming.draws` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameDrawRows(records) {
+    return listRows(records, (data) => namingOf(data).draws, ["kind", "elements"], {
+        lists: ["elements"],
+    });
+}
+
+/**
+ * The `held_from` rows: one per `data.naming.heldFrom` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function heldFromRows(records) {
+    return listRows(
+        records,
+        (data) => namingOf(data).heldFrom,
+        ["source", "takes", "clip", "genitive", "elements"],
+        { lists: ["genitive", "elements"] },
+    );
+}
+
+/**
+ * The `near_names` rows: one per worked example of `data.naming.nearName`,
+ * each with the language's `min_syllables`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nearNameRows(records) {
+    const rows = [];
+    for (const [language, record] of languagesOf(records)) {
+        const near = namingOf(isMap(record.data) ? record.data : {}).nearName;
+        if (!isMap(near) || !Array.isArray(near.examples)) continue;
+        near.examples.forEach((example, position) => {
+            if (!isMap(example)) return;
+            rows.push({
+                language,
+                position,
+                near: example.near ?? null,
+                given: example.given ?? null,
+                min_syllables: near.minSyllables ?? null,
+            });
+        });
+    }
+    return rows;
+}
+
 /**
  * The `read_past` rows: one per `data.sounds.readPast` entry.
  *
@@ -482,8 +696,8 @@ export function readPastRows(records) {
 
 /**
  * The `sound_changes` rows: one per step of each `data.soundChanges` set, with
- * the set's `position`, `name`, `from_language` and `to_language`, and the
- * step's `step_position` within it.
+ * the set's `position`, `name`, `from_language`, `to_language` and `takes`,
+ * and the step's `step_position` within it.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -503,6 +717,7 @@ export function soundChangeRows(records) {
                     name: set.name ?? null,
                     from_language: set.from ?? null,
                     to_language: set.to ?? null,
+                    takes: set.takes ?? null,
                     step_position: stepPosition,
                 };
                 for (const key of SOUND_CHANGE_STEP_KEYS) row[key] = step[key] ?? null;
@@ -592,7 +807,8 @@ export function finalRows(records) {
 /**
  * The `syllables` rows: one per language stating `data.sounds.syllables`, a
  * list rule always a list (`any` a list of one), the harmony's sets each a
- * column of its own.
+ * column of its own, its partners a list of `{ vowel, partner }` in the order
+ * stated.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -618,6 +834,13 @@ export function syllableRows(records) {
             harmony_front: asList(harmony.front),
             harmony_neutral: asList(harmony.neutral),
             harmony_neutralAs: harmony.neutralAs ?? null,
+            harmony_partners:
+                isMap(harmony.partners) && Object.keys(harmony.partners).length ?
+                    Object.entries(harmony.partners).map(([vowel, partner]) => ({
+                        vowel,
+                        partner: partner == null ? null : String(partner),
+                    }))
+                :   null,
         });
     }
     return rows;
@@ -744,6 +967,8 @@ export const LANGUAGE_RELATIONS = Object.freeze([
     ["letters", letterRows, LETTER_COLUMNS],
     ["edges", edgeRows, EDGE_COLUMNS],
     ["clusters", clusterRows, CLUSTER_COLUMNS],
+    ["cluster_groups", clusterGroupRows, CLUSTER_GROUP_COLUMNS],
+    ["mutations", mutationRows, MUTATION_COLUMNS],
     ["stress", stressRows, STRESS_COLUMNS],
     ["finals", finalRows, FINAL_COLUMNS],
     ["syllables", syllableRows, SYLLABLE_COLUMNS],
@@ -758,4 +983,11 @@ export const LANGUAGE_RELATIONS = Object.freeze([
     ["roots", rootRows, ROOT_COLUMNS],
     ["cognates", cognateRows, COGNATE_COLUMNS],
     ["calling_names", callingNameRows, CALLING_NAME_COLUMNS],
+    ["older", olderRows, OLDER_COLUMNS],
+    ["negation", negationRows, NEGATION_COLUMNS],
+    ["name_shapes", nameShapeRows, NAME_SHAPE_COLUMNS],
+    ["name_edges", nameEdgeRows, NAME_EDGE_COLUMNS],
+    ["name_draws", nameDrawRows, NAME_DRAW_COLUMNS],
+    ["held_from", heldFromRows, HELD_FROM_COLUMNS],
+    ["near_names", nearNameRows, NEAR_NAME_COLUMNS],
 ]);