@heroiclands/package-build 24.0.1 → 24.0.2

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

@@ -6,6 +6,19 @@
  * @returns {boolean}
  */
 export function tongueDeclared(tag: string, declared: Set<string>): boolean;
+/**
+ * Check a `doc` note's `data.sounds`, a spelling guide's letters and marks:
+ * each letter row's `tongue` names language notes. The data-key check owns
+ * the keys, so a sound rule a guide does not state is refused there.
+ *
+ * @param {object} note - A `doc` note: `file`, `raw` and parsed `fm`.
+ * @param {object} [context]
+ * @param {object} [context.index] - The index, for whether an Address resolves.
+ * @returns {object[]} The findings.
+ */
+export function checkGuideSounds(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];
 /**
  * Check a `skill` note's language data against what it means.
  *

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

@@ -42,8 +42,8 @@ export function tongueRows(records: Iterable<Record<string, any>>): object[];
  */
 export function scopeRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
- * `tongue` lists.
+ * The `letters` rows: one per `data.sounds.letters` entry of a language note
+ * or a spelling guide, `letters` and `tongue` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -207,7 +207,8 @@ export function joiningRows(records: Iterable<Record<string, any>>): object[];
  */
 export function joinRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `marks` rows: one per `data.sounds.marks` entry.
+ * The `marks` rows: one per `data.sounds.marks` entry of a language note or a
+ * spelling guide.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}

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

@@ -233,6 +233,13 @@ export const MUTATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a spelling guide's `data.sounds`: a `doc` note stating the
+ * letters and marks every tongue of a setting is written by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const GUIDE_SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of one `data.soundChanges` entry.
  *

package/types/engine/map-lexicon.d.mts

@@ -151,14 +151,15 @@ export function transliterate(ctx: object, keys: {
  * writing, the signs a run writes directly for that sense.
  *
  * @param {object} ctx - The run context.
- * @param {{lang: string, map: string, font?: string, derived?: boolean}} keys -
- *   The language, the map, the face, and whether to list derived forms.
+ * @param {{lang: string, map?: string, font?: string, derived?: boolean}} keys -
+ *   The language, the map, the face, and whether to list derived forms. A map
+ *   or a face left out is the one the language's `data.writtenIn` names.
  * @returns {{entries: Array<{form: string, native: string, exception?: boolean, source?: "own"|"parts"|"none", ambiguous?: true, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
  *   The words in `data.words` order, then any derived forms, or the problem.
  */
 export function lexiconEntries(ctx: object, { lang, map, font, derived }: {
     lang: string;
-    map: string;
+    map?: string;
     font?: string;
     derived?: boolean;
 }): {

package/types/engine/pdf-fonts.d.mts

@@ -1,3 +1,13 @@
+/**
+ * The tables an sfnt file holds, by tag.
+ *
+ * @param {Buffer} buf - The font file.
+ * @returns {Map<string, {offset: number, length: number}>} Its table directory.
+ */
+export function tableDirectory(buf: Buffer): Map<string, {
+    offset: number;
+    length: number;
+}>;
 /**
  * Every glyph name a font carries, with the codepoint that reaches it.
  *

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

@@ -2,12 +2,14 @@
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"verse"} kind - The construct.
+ * @property {"span"|"block"|"verse"|"scroll"} 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.
- * @property {string|null} font - Its font, as written and inherited the same way.
- * @property {string|null} map - Its map, as written and inherited the same way.
+ * @property {string|null} font - Its font, as written and inherited the same
+ *   way, else its language's script's.
+ * @property {string|null} map - Its map, as written and inherited the same way,
+ *   else its language's script's.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -33,6 +35,24 @@ export function recordRuns(body: string, { context, bodyLine, bodyColumn, syntax
     bodyColumn?: number | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
 }): RecordRun[];
+/**
+ * Give every recorded run the map and face its language's note names in
+ * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
+ * once every record exists, since a run's language note may be recorded after
+ * the note that marks it.
+ *
+ * @param {Record<string, any>[]} records - The package's index records; each
+ *   note record's `runs` is updated in place.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The configured languages, whose `note` names each language note.
+ */
+export function fillWrittenIn(records: Record<string, any>[], config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): void;
 /**
  * The containing page's NOTE identity.
  *
@@ -57,7 +77,7 @@ export type RecordRun = {
     /**
      * - The construct.
      */
-    kind: "span" | "block" | "verse";
+    kind: "span" | "block" | "verse" | "scroll";
     /**
      * - The language it is set in, as written: its
      * own `lang=`, else the one the div or fence around it states.
@@ -68,11 +88,13 @@ export type RecordRun = {
      */
     tag: string | null;
     /**
-     * - Its font, as written and inherited the same way.
+     * - Its font, as written and inherited the same
+     * way, else its language's script's.
      */
     font: string | null;
     /**
-     * - Its map, as written and inherited the same way.
+     * - Its map, as written and inherited the same way,
+     * else its language's script's.
      */
     map: string | null;
     /**

package/types/engine/script-direction.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Each face's direction, from the script notes among the index records. The
+ * first note to list a face keeps it; a face whose note states no direction,
+ * or one the build does not know, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @returns {Map<string, "vertical-rl">} The directions, by face slug.
+ */
+export function directionsFromRecords(records: Iterable<Record<string, any>> | undefined): Map<string, "vertical-rl">;
+export { SCRIPT_DIRECTIONS } from "./script-emphasis-terms.mjs";

package/types/engine/script-emphasis-terms.d.mts

@@ -1,7 +1,8 @@
 /**
- * **The words a script note and a language note state emphasis by.** Read by
- * the vocabulary as it is declared, so this module imports nothing; the
- * checks and the conventions' use are in {@link module:engine/script-emphasis}.
+ * **The words a script note and a language note state emphasis and direction
+ * by.** Read by the vocabulary as it is declared, so this module imports
+ * nothing; the checks and the conventions' use are in
+ * {@link module:engine/script-emphasis} and {@link module:engine/script-direction}.
  *
  * @module
  */
@@ -17,5 +18,11 @@ export const EMPHASIS_CLASSES: Readonly<{
  * `words` marks emphasis with a word, so a mark in its text is a finding.
  */
 export const LANGUAGE_EMPHASES: readonly string[];
+/**
+ * The directions a script states it is written in. `vertical-rl` is columns,
+ * top to bottom, read from the right; a script stating none is written in
+ * lines.
+ */
+export const SCRIPT_DIRECTIONS: readonly string[];
 /** The `subType` of a script note. */
 export const SCRIPT_SUBTYPE: "script";

package/types/engine/script-font-delivery.d.mts

@@ -1,7 +1,9 @@
 /**
- * The faces the package's notes set text in with `font=`, read from the
- * notes themselves: every Markdown file under the content tree that writes
- * `font=` is scanned for its runs.
+ * The faces the package's notes set text in, read from the notes
+ * themselves: every Markdown file under the content tree that writes `font=`
+ * is scanned for its runs, and the face every language note names in
+ * `data.writtenIn` counts, since a run marked with the language alone is set
+ * in it.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.

package/types/engine/script-fonts.d.mts

@@ -28,6 +28,9 @@
  * @property {string} direction - `ltr` or `rtl`.
  * @property {string[]} features - OpenType features it turns on.
  * @property {ReadonlySet<number>} draws - Every code point it draws.
+ * @property {string|undefined} file - The absolute path of its TrueType file,
+ *   which the book draws a `scroll` fence's outlines from; `undefined` when the
+ *   manifest lists none.
  */
 /**
  * The installed fonts package, as a consumer sees it.
@@ -140,6 +143,12 @@ export type Face = {
      * - Every code point it draws.
      */
     draws: ReadonlySet<number>;
+    /**
+     * - The absolute path of its TrueType file,
+     * which the book draws a `scroll` fence's outlines from; `undefined` when the
+     * manifest lists none.
+     */
+    file: string | undefined;
 };
 /**
  * The installed fonts package, as a consumer sees it.

package/types/engine/written-in.d.mts

@@ -0,0 +1,76 @@
+/**
+ * Whether a map is drawn in a face: it lists the face, or lists none.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {boolean} Whether the map may set text in it.
+ */
+export function drawnIn(map: import("./text-maps.mjs").TextMap, font: string): boolean;
+/**
+ * The script each configured language's note names, where the map is known
+ * and is drawn in the face. A default that names an unknown map or a face its
+ * map is not drawn in is the note's finding, and fills no run.
+ *
+ * @param {ReadonlyMap<string, Record<string, any>>} byName - Each configured
+ *   language's note record, by language name, from
+ *   {@link module:engine/map-lexicon.languageRecordsByName}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>} maps - The
+ *   maps by name.
+ * @returns {Map<string, WrittenIn>} The scripts, by language name.
+ */
+export function writtenInOf(byName: ReadonlyMap<string, Record<string, any>>, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap>): Map<string, WrittenIn>;
+/**
+ * The keys a run takes from its language's script: each of `map` and `font`
+ * the run does not state, where it agrees with the one the run does.
+ *
+ * @param {{lang?: string, map?: string, font?: string}} keys - The run's keys,
+ *   its own and those it inherits.
+ * @param {ReadonlyMap<string, WrittenIn>|undefined} scripts - Each language's
+ *   script, from {@link writtenInOf}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>|undefined} maps -
+ *   The maps by name.
+ * @returns {{map?: string, font?: string}} What the run takes; empty when it
+ *   takes nothing.
+ */
+export function fromWrittenIn(keys: {
+    lang?: string;
+    map?: string;
+    font?: string;
+}, scripts: ReadonlyMap<string, WrittenIn> | undefined, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined): {
+    map?: string;
+    font?: string;
+};
+/**
+ * Check a note's `data.writtenIn`: that the note is a language, that `map`
+ * names a map a mapping note declares, and that the map is drawn in `font`.
+ * The data-key check owns the keys and their kinds.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index;
+ *   without one, only the note's `subType` is checked.
+ * @returns {object[]} The findings, each at its key or value.
+ */
+export function checkWrittenIn(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, { index }?: {
+    index?: {
+        notes?: Iterable<object>;
+    };
+}): object[];
+/** The `data` key a language note names its script in. */
+export const WRITTEN_IN_KEY: "writtenIn";
+/**
+ * A language's script.
+ */
+export type WrittenIn = {
+    /**
+     * - The `data.map.name` of the mapping note.
+     */
+    map: string;
+    /**
+     * - The slug of the face, one the map is drawn in.
+     */
+    font: string;
+};