@heroiclands/package-build 25.0.0 → 25.1.1

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

@@ -1,189 +0,0 @@
-/**
- * Read one authored row.
- *
- * @param {unknown} row - The row as YAML gave it.
- * @returns {{row: MapRow}|{problem: string, key?: string}} The row, or what is
- *   wrong with it and the key the fault sits at.
- */
-export function readMapRow(row: unknown): {
-    row: MapRow;
-} | {
-    problem: string;
-    key?: string;
-};
-/**
- * Compile a `data.map` value, keeping its well-formed rows.
- *
- * @param {unknown} value - The note's `data.map`.
- * @returns {TextMap|undefined} The map, or `undefined` when it has no valid name.
- */
-export function compileMap(value: unknown): TextMap | undefined;
-/**
- * A native form found for a word in lowercase, given the word's capital as the
- * rows write it: the rows map the word's first sound as written and in
- * lowercase, and where the native form begins with the lowercase result, that
- * beginning becomes the capital one.
- *
- * @param {TextMap} map - The map.
- * @param {string|undefined} font - The face.
- * @param {string} word - The word as written.
- * @param {string} native - The native form of its lowercase.
- * @returns {string|undefined} The native form, capitalised; `undefined` where
- *   it does not begin as the rows begin the word, so the rows cannot say how.
- */
-export function capitalNative(map: TextMap, font: string | undefined, word: string, native: string): string | undefined;
-/**
- * Apply a map to text.
- *
- * @param {TextMap|undefined} map - The map; without one the text is returned
- *   as it is.
- * @param {string} text - The text, with no escapes in it.
- * @param {MapOptions} [options] - The face, and the native forms of words.
- * @returns {{text: string, pieces: Array<{at: number, from: string, to: string, row: boolean, native?: boolean, unwritten?: object}>}}
- *   The rewritten text, and each piece of it with the UTF-16 offset in `text`
- *   it came from: a matched row's `from` and what it wrote, a word and its
- *   native form (`native: true`), or one character that passed through. A
- *   capitalised word whose native form the rows cannot capitalise is written
- *   as stated and carries `uncapitalised`, the lowercase form it was found by.
- *   Under a logographic map, a word with no writing is written as typed and
- *   carries `unwritten`, why it has none.
- */
-export function applyMap(map: TextMap | undefined, text: string, { font, native, writing }?: MapOptions): {
-    text: string;
-    pieces: Array<{
-        at: number;
-        from: string;
-        to: string;
-        row: boolean;
-        native?: boolean;
-        unwritten?: object;
-    }>;
-};
-/**
- * Every map the index records declare, by name. The first note to declare a
- * name keeps it; the duplicate is the lint's to report.
- *
- * @param {Iterable<Record<string, any>>|undefined} records - Index records.
- * @returns {Map<string, TextMap>} The maps.
- */
-export function mapsFromRecords(records: Iterable<Record<string, any>> | undefined): Map<string, TextMap>;
-/**
- * One row per well-formed map row, for the `maps` relation: the shared rows
- * with no `font`, then each listed face's own rows with its slug.
- *
- * @param {Iterable<Record<string, any>>} records - Index records.
- * @param {(record: Record<string, any>) => string|null} ownerOf - A record's
- *   page Address.
- * @returns {Array<Record<string, string|number|null>>} The rows, in record
- *   then authored order; `row` is the row's 1-based place in its list.
- */
-export function mapRows(records: Iterable<Record<string, any>>, ownerOf: (record: Record<string, any>) => string | null): Array<Record<string, string | number | null>>;
-/**
- * Check a note's `data.map`: its name, that no other note declares it, each
- * row written as a list, a `before` condition on a map with no `vowels`, an
- * empty `fonts`, a generic family in it, and a row of a logographic map that
- * matches a letter. The data-key check owns every
- * key, its kind and the words a condition takes; whether a listed face is
- * installed, and draws what the map writes, is
- * {@link module:engine/map-lexicon.checkMapFonts}'s.
- *
- * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
- * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index.
- * @returns {object[]} The findings, each at its key.
- */
-export function checkMapField(note: {
-    file: string;
-    raw?: string;
-    fm?: Record<string, any>;
-}, { index }?: {
-    index?: {
-        notes?: Iterable<object>;
-    };
-}): object[];
-/** What a map's `name` may be. */
-export const MAP_NAME: RegExp;
-/** Each condition a row may carry, and the values it takes. */
-export const MAP_CONDITIONS: Readonly<{
-    before: readonly string[];
-    at: readonly string[];
-}>;
-/** The generic families, which a map's `fonts` may not list. */
-export const GENERIC_FAMILIES: readonly string[];
-/** Every column of the `maps` relation, in order. */
-export const MAP_COLUMNS: readonly string[];
-/**
- * One row, read.
- */
-export type MapRow = {
-    /**
-     * - The characters it matches.
-     */
-    from: string;
-    /**
-     * - What it writes in their place.
-     */
-    to: string;
-    /**
-     * - What must follow the match.
-     */
-    before?: "vowel" | "consonant" | undefined;
-    /**
-     * - Where the match must sit.
-     */
-    at?: "start" | "end" | undefined;
-};
-/**
- * A map ready to apply.
- */
-export type TextMap = {
-    /**
-     * - Its name.
-     */
-    name: string;
-    /**
-     * - Whether it writes words from the lexicon
-     * alone, its rows only between them.
-     */
-    logographic: boolean;
-    /**
-     * - The characters `before: vowel` reads.
-     */
-    vowels: ReadonlySet<string>;
-    /**
-     * - Its well-formed shared rows, in authored order.
-     */
-    rows: readonly MapRow[];
-    /**
-     * - Its shared rows
-     * by the first character of `from`, longest first, conditioned before plain.
-     */
-    byFirst: ReadonlyMap<string, readonly MapRow[]>;
-    /**
-     * -
-     * Each listed face by slug, in listed order, with its own rows.
-     */
-    fonts: ReadonlyMap<string, {
-        rows: readonly MapRow[];
-        byFirst: ReadonlyMap<string, readonly MapRow[]>;
-    }>;
-};
-/**
- * How a text is mapped beyond the rows.
- */
-export type MapOptions = {
-    /**
-     * - The face the text is set in, whose own rows are
-     * tried first.
-     */
-    font?: string | undefined;
-    /**
-     * - A word's native
-     * form, for the word exactly as given, or `undefined` where it states none.
-     */
-    native?: ((word: string) => string | undefined) | undefined;
-    /**
-     * -
-     * A word's writing under a logographic map; without one, no word has one.
-     */
-    writing?: ((word: string) => import("./logographic.mjs").Writing) | undefined;
-};

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

@@ -1,76 +0,0 @@
-/**
- * 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;
-};