@heroiclands/package-build 23.7.0 → 23.7.1

package/engine/language-words.mjs

@@ -28,6 +28,10 @@
  * - no form stands twice in one language;
  * - a word's `gloss` states at least one sense;
  * - an affix that `replaces` the stem's close does not also `lengthen` it;
+ * - an affix states `given` only where its `kind` is `name`;
+ * - an affix states a `form` or `zero: true`, never both;
+ * - an element's `word` and the particle of `data.negation` are forms of the
+ *   words of the language or an ancestor;
  * - a word's `frame` names a frame of `data.sounds.frames`, its language's or
  *   an ancestor's;
  * - every source language resolves, and names a language skill;
@@ -51,6 +55,7 @@ import { addressKeyOf, ownKey } from "./culture-reach.mjs";
 import {
     BORROWED_SOURCE_KIND,
     LANGUAGE_SUBTYPE,
+    NAME_AFFIX_KIND,
     WORD_DATA_KEYS,
     glossSenses,
     pronunciationProblem,
@@ -287,6 +292,76 @@ export function checkLanguageWords(note, { index } = {}) {
         });
     });
 
+    listOf(data.affixes).forEach((affix, i) => {
+        if (!isMap(affix)) return;
+        const form = typeof affix.form === "string" && affix.form.trim() !== "";
+        const zero = affix.zero === true;
+        if (form && zero)
+            findings.push(
+                finding(
+                    ["data", "affixes", i, "zero"],
+                    "error",
+                    `\`data.affixes[${i}]\` states a \`form\` and \`zero: true\`; a zero affix states no form`,
+                    true,
+                ),
+            );
+        else if (!form && !zero && affix.form == null)
+            findings.push(
+                finding(
+                    ["data", "affixes", i],
+                    "error",
+                    `\`data.affixes[${i}]\` states neither a \`form\` nor \`zero: true\``,
+                ),
+            );
+    });
+
+    listOf(data.affixes).forEach((affix, i) => {
+        if (!isMap(affix) || affix.given == null || affix.kind === NAME_AFFIX_KIND) return;
+        findings.push(
+            finding(
+                ["data", "affixes", i, "given"],
+                "error",
+                "`given` says who a given name belongs to, and " +
+                    (typeof affix.kind === "string" ?
+                        `\`data.affixes[${i}]\` is of kind \`${affix.kind}\``
+                    :   `\`data.affixes[${i}]\` is of no kind`) +
+                    `; it is stated on an affix of kind \`${NAME_AFFIX_KIND}\` only`,
+                true,
+            ),
+        );
+    });
+
+    // The forms an element's `word` and the negative particle may name.
+    const wordForms = new Set();
+    for (const one of [data, ...ancestors])
+        for (const word of listOf(one?.words))
+            if (isMap(word) && typeof word.form === "string") wordForms.add(word.form);
+    listOf(data.elements).forEach((element, i) => {
+        if (!isMap(element) || typeof element.word !== "string" || wordForms.has(element.word))
+            return;
+        findings.push(
+            finding(
+                ["data", "elements", i, "word"],
+                "error",
+                `the word \`${element.word}\` of the element \`${element.form}\` is not a form of ` +
+                    "this language's words or its ancestors'",
+            ),
+        );
+    });
+    if (
+        isMap(data.negation) &&
+        typeof data.negation.particle === "string" &&
+        !wordForms.has(data.negation.particle)
+    )
+        findings.push(
+            finding(
+                ["data", "negation", "particle"],
+                "error",
+                `the negative particle \`${data.negation.particle}\` is not a form of this ` +
+                    "language's words or its ancestors'",
+            ),
+        );
+
     listOf(data.affixes).forEach((affix, i) => {
         if (!isMap(affix) || affix.lengthens !== true || affix.replaces == null) return;
         findings.push(

package/engine/sql-tables.mjs

@@ -654,7 +654,9 @@ async function createWordRelations(connection, stem, records, prefix, audience)
  * @param {readonly string[]} columns - Its columns, for the empty case.
  * @param {Readonly<Record<string, string>>} [types] - Each column's type, for
  *   the empty case; a column it leaves out is text. Without it, a whole-number
- *   column is a number and every other column text.
+ *   column is a number and every other column text. A `DOUBLE` column is cast
+ *   whatever the rows hold, because a fraction written whole reads as an
+ *   integer.
  * @returns {Promise<void>}
  */
 async function createRowRelation(connection, file, rows, view, columns, types) {
@@ -670,7 +672,15 @@ async function createRowRelation(connection, file, rows, view, columns, types) {
         return;
     }
     fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join("\n"));
-    await createTableFromFile(connection, view, readJsonAuto(file));
+    const fractions = Object.entries(types ?? {})
+        .filter(([, type]) => type === "DOUBLE")
+        .map(([column]) => `CAST("${column}" AS DOUBLE) AS "${column}"`);
+    const source = readJsonAuto(file);
+    await createTableFromFile(
+        connection,
+        view,
+        fractions.length ? `SELECT * REPLACE (${fractions.join(", ")}) FROM (${source})` : source,
+    );
 }
 
 /**

package/engine/word-rows.mjs

@@ -38,6 +38,7 @@ import { renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
 import {
     AFFIX_KEYS,
+    ZERO_AFFIX,
     FIELD_KEYS,
     GLOSSARY_ENTRY_KEYS,
     LANGUAGE_SUBTYPE,
@@ -63,7 +64,7 @@ export const WORD_COLUMNS = Object.freeze([
 export const GLOSSARY_COLUMNS = Object.freeze(["note", "position", ...GLOSSARY_ENTRY_KEYS]);
 
 /** Every column of the `affixes` relation, in order. */
-export const AFFIX_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...AFFIX_KEYS]);
+export const AFFIX_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...AFFIX_KEYS, "written"]);
 
 /** Every column of the `fields` relation, in order. */
 export const FIELD_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...FIELD_KEYS]);
@@ -299,14 +300,18 @@ function languageListRows(records, list, keys) {
 
 /**
  * The `affixes` rows of a set of index records: one per `data.affixes` entry
- * of a language note, which is the row's `language`.
+ * of a language note, which is the row's `language`, with `written`, the form
+ * as a table prints it: `∅` for a zero affix, whose `form` is `NULL`.
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.
  * @returns {object[]} One row per affix, in record then entry order.
  */
 export function affixRows(records) {
-    return languageListRows(records, "affixes", AFFIX_KEYS);
+    return languageListRows(records, "affixes", AFFIX_KEYS).map((row) => ({
+        ...row,
+        written: row.zero === true ? ZERO_AFFIX : row.form,
+    }));
 }
 
 /**

package/engine/word-terms.mjs

@@ -44,6 +44,30 @@ export const WORD_SOURCE_KINDS = Object.freeze([
     "island",
 ]);
 
+/**
+ * What an affix makes: a case, a word derived from another, a verb's tense,
+ * aspect, mood or voice, a given name's ending, or a lineage name's ending.
+ */
+export const AFFIX_KINDS = Object.freeze([
+    "case",
+    "derivation",
+    "tense",
+    "aspect",
+    "mood",
+    "voice",
+    "name",
+    "lineage",
+]);
+
+/** The affix kind whose ending says who the name is given to. */
+export const NAME_AFFIX_KIND = "name";
+
+/** How a zero affix is written where a table prints it. */
+export const ZERO_AFFIX = "∅";
+
+/** Who a given name's ending is given to. */
+export const AFFIX_GIVEN = Object.freeze(["man", "woman", "either"]);
+
 /** The source kind that requires `language`. */
 export const BORROWED_SOURCE_KIND = "borrowed";
 
@@ -240,9 +264,36 @@ export const AFFIX_FIELDS = Object.freeze([
     Object.freeze({
         name: "form",
         kind: "string",
-        required: true,
         shape: "the affix as written, such as `-rith`",
-        describe: "The affix as a word's `built` names it.",
+        describe: "The affix as a word's `built` names it; absent on a zero affix.",
+    }),
+    Object.freeze({
+        name: "zero",
+        kind: "boolean",
+        shape: "`true`",
+        describe:
+            "The affix is written as nothing, such as a case with no ending; it states no " +
+            `\`form\`, prints as \`${ZERO_AFFIX}\`, and no \`built\` piece names it.`,
+    }),
+    Object.freeze({
+        name: "kind",
+        kind: "string",
+        allowed: AFFIX_KINDS,
+        shape: `one of ${AFFIX_KINDS.join(", ")}`,
+        describe: "What the affix makes.",
+    }),
+    Object.freeze({
+        name: "given",
+        kind: "string",
+        allowed: AFFIX_GIVEN,
+        shape: `one of ${AFFIX_GIVEN.join(", ")}`,
+        describe: `Who a given name closing on it belongs to; an affix of kind \`${NAME_AFFIX_KIND}\` only.`,
+    }),
+    Object.freeze({
+        name: "where",
+        kind: "string",
+        shape: "a string, such as `before a stop`",
+        describe: "Where this form stands, for an affix written two ways; everywhere where absent.",
     }),
     Object.freeze({
         name: "gloss",
@@ -286,6 +337,13 @@ export const AFFIX_FIELDS = Object.freeze([
         entries: Object.freeze({ kind: "string", shape: "a string" }),
         describe: "The names the affix is read from.",
     }),
+    Object.freeze({
+        name: "barredAfter",
+        kind: "list",
+        shape: "a list of sounds",
+        entries: Object.freeze({ kind: "string", shape: "a sound as written" }),
+        describe: "The sounds a stem may not close on to take the affix.",
+    }),
     Object.freeze({
         name: "tones",
         kind: "string",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.7.0",
+    "version": "23.7.1",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

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

@@ -63,6 +63,73 @@ export function edgeRows(records: Iterable<Record<string, any>>): object[];
  * @returns {object[]}
  */
 export function clusterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * 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: Iterable<Record<string, any>>): object[];
+/**
+ * The `mutations` rows: one per `data.sounds.mutations` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function mutationRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `older` rows: one per `data.older` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function olderRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `negation` rows: one per language stating `data.negation`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function negationRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * 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: Iterable<Record<string, any>>): object[];
+/**
+ * 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: Iterable<Record<string, any>>): object[];
+/**
+ * The `name_draws` rows: one per `data.naming.draws` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameDrawRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `held_from` rows: one per `data.naming.heldFrom` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function heldFromRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * 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: Iterable<Record<string, any>>): object[];
 /**
  * The `read_past` rows: one per `data.sounds.readPast` entry.
  *
@@ -72,8 +139,8 @@ export function clusterRows(records: Iterable<Record<string, any>>): object[];
 export function readPastRows(records: Iterable<Record<string, any>>): object[];
 /**
  * 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[]}
@@ -118,7 +185,8 @@ export function finalRows(records: Iterable<Record<string, any>>): object[];
 /**
  * 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[]}
@@ -182,6 +250,24 @@ export const LETTER_COLUMNS: readonly string[];
 export const EDGE_COLUMNS: readonly string[];
 /** Every column of the `clusters` relation, in order. */
 export const CLUSTER_COLUMNS: readonly string[];
+/** Every column of the `cluster_groups` relation, in order. */
+export const CLUSTER_GROUP_COLUMNS: readonly string[];
+/** Every column of the `mutations` relation, in order. */
+export const MUTATION_COLUMNS: readonly string[];
+/** Every column of the `older` relation, in order. */
+export const OLDER_COLUMNS: readonly string[];
+/** Every column of the `name_shapes` relation, in order. */
+export const NAME_SHAPE_COLUMNS: readonly string[];
+/** Every column of the `name_edges` relation, in order. */
+export const NAME_EDGE_COLUMNS: readonly string[];
+/** Every column of the `name_draws` relation, in order. */
+export const NAME_DRAW_COLUMNS: readonly string[];
+/** Every column of the `held_from` relation, in order. */
+export const HELD_FROM_COLUMNS: readonly string[];
+/** Every column of the `near_names` relation, in order. */
+export const NEAR_NAME_COLUMNS: readonly string[];
+/** Every column of the `negation` relation, in order: one row per language. */
+export const NEGATION_COLUMNS: readonly string[];
 /** Every column of the `stress` relation, in order. */
 export const STRESS_COLUMNS: readonly string[];
 /** Every column of the `finals` relation, in order. */

package/types/engine/language-terms.d.mts

@@ -2,13 +2,15 @@
  * The keys a language note states beside its words: the register of the names
  * the setting gives in the language's reach, the tags the register uses, the
  * forms it does not write, the notes the register covers, the letters and sound
- * rules, the sound changes, the name elements, the roots and the cognates.
+ * rules, the sound changes, the name elements, the roots, the cognates, the
+ * forms older than the rules and the negative particle.
  *
  * A leaf module, importing nothing: the note vocabulary reads these
  * declarations as it loads, and `language-data.mjs` checks what the values
  * mean. Every closed list here — the edges, element positions, register
- * kinds, stress rules, joins, marks, onsets, harmony sets and calling-name
- * uses — holds the labels the setting's own tables use, one word for each.
+ * kinds, stress rules, joins, marks, onsets, harmony sets, cluster uses and
+ * calling-name uses — holds the labels the setting's own tables use, one word
+ * for each.
  *
  * @module
  */
@@ -48,8 +50,30 @@ export const ANY_SOUND: "any";
  * never begins or ends a name.
  */
 export const ELEMENT_POSITIONS: readonly string[];
-/** What a register name is, where a language sorts its names by kind. */
+/**
+ * What a register name is, where a language sorts its names by kind, and the
+ * kind of name an element builds.
+ */
 export const REGISTER_KINDS: readonly string[];
+/**
+ * The class of name a naming shape or edge holds for: every name, a given or a
+ * clan name, or a name by how it is built — `bound` a stem and an ending,
+ * `compound` elements alone.
+ */
+export const NAME_CLASSES: readonly string[];
+/** The class of name a naming edge holds for where it states none. */
+export const ANY_NAME: "name";
+/**
+ * What a place name takes first from what it is held from: a name-stem, a
+ * god's name, a founder's given name, or one of the listed elements.
+ */
+export const HELD_TAKES: readonly string[];
+/** The `takes` values that are a name a place name shapes. */
+export const HELD_NAMES: readonly string[];
+/** How a name is clipped where a place name takes it. */
+export const HELD_CLIPS: readonly string[];
+/** How often a group of clusters stands inside a word. */
+export const CLUSTER_USES: readonly string[];
 /** Where a language's stress falls. */
 export const STRESS_RULES: readonly string[];
 /** Which sounds meet where two parts of a word join. */
@@ -106,6 +130,13 @@ export const LETTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.clusters.groups` entry: clusters of one kind,
+ * and how often they stand.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CLUSTER_GROUP_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of a language's `data.sounds.clusters`.
  *
@@ -172,6 +203,13 @@ export const SKELETON_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const FRAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.mutations` entry: a sound and what it becomes
+ * where a named mutation holds.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const MUTATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of a language's `data.sounds`.
  *
@@ -223,6 +261,64 @@ export const CALLING_CLOSING_FIELDS: readonly import("./data-keys.mjs").InnerKey
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const CALLING_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.older` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const OLDER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.negation`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEGATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.shapes` entry: how long a class of name runs.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_SHAPE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.edges` entry: the sounds a name may open or
+ * close on, where a name keeps edges ordinary words do not.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.draws` entry: the element kinds a kind of name
+ * is built from.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_DRAW_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.heldFrom` entry: what a place name takes first
+ * from what the place is held from.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HELD_FROM_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.nearName.examples` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEAR_NAME_EXAMPLE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.naming.nearName`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEAR_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.naming`: the parameters its names keep
+ * beyond the rules its words keep.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The `data` fields this module declares, in the order the vocabulary lists
  * them. {@link module:engine/language-data.checkLanguageData} checks what the
@@ -261,5 +357,11 @@ export const CALLING_CLOSING_KEYS: readonly string[];
 export const ELEMENT_KEYS: readonly string[];
 /** The keys of {@link ROOT_FIELDS}, in declared order. */
 export const ROOT_KEYS: readonly string[];
+/** The keys of {@link MUTATION_FIELDS}, in declared order. */
+export const MUTATION_KEYS: readonly string[];
+/** The keys of {@link CLUSTER_GROUP_FIELDS}, in declared order. */
+export const CLUSTER_GROUP_KEYS: readonly string[];
+/** The keys of {@link OLDER_FIELDS}, in declared order. */
+export const OLDER_KEYS: readonly string[];
 /** The keys of {@link SCOPE_FIELDS}, in declared order. */
 export const SCOPE_KINDS: readonly string[];

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

@@ -78,7 +78,8 @@ export function citationLookup(records: Iterable<Record<string, any>>): (languag
 export function wordRows(records: Iterable<Record<string, any>>, all?: Iterable<Record<string, any>>): object[];
 /**
  * The `affixes` rows of a set of index records: one per `data.affixes` entry
- * of a language note, which is the row's `language`.
+ * of a language note, which is the row's `language`, with `written`, the form
+ * as a table prints it: `∅` for a zero affix, whose `form` is `NULL`.
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.

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

@@ -45,6 +45,17 @@ export const WORD_DATA_KEYS: readonly string[];
  * one; `coined`, `substrate` and `island` name no form.
  */
 export const WORD_SOURCE_KINDS: readonly string[];
+/**
+ * What an affix makes: a case, a word derived from another, a verb's tense,
+ * aspect, mood or voice, a given name's ending, or a lineage name's ending.
+ */
+export const AFFIX_KINDS: readonly string[];
+/** The affix kind whose ending says who the name is given to. */
+export const NAME_AFFIX_KIND: "name";
+/** How a zero affix is written where a table prints it. */
+export const ZERO_AFFIX: "\u2205";
+/** Who a given name's ending is given to. */
+export const AFFIX_GIVEN: readonly string[];
 /** The source kind that requires `language`. */
 export const BORROWED_SOURCE_KIND: "borrowed";
 /**