@heroiclands/package-build 23.3.1 → 23.4.0

package/types/engine/appearance-features.d.mts

@@ -0,0 +1,66 @@
+/**
+ * The punctuation an entry carries, a hyphen or apostrophe between letters
+ * excepted.
+ *
+ * @param {string} entry - The entry as written.
+ * @returns {string[]} Each distinct character, in order of appearance.
+ */
+export function featurePunctuation(entry: string): string[];
+/**
+ * Why an `extra_features` entry is not a short plain description of one
+ * physical mark.
+ *
+ * @param {string} entry - The entry as written.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} look - The
+ *   being-look vocabulary.
+ * @returns {Array<{rule: string, message: string}>} One problem per rule the
+ *   entry breaks; empty when it is a mark. `rule` is `hair-colour`,
+ *   `eye-colour`, `skin-colour`, `complexion`, `punctuation`, or a rule of
+ *   {@link NON_PHYSICAL_FEATURES}.
+ */
+export function featureProblems(entry: string, look: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): Array<{
+    rule: string;
+    message: string;
+}>;
+/**
+ * The frontmatter lint's check of `data.appearance.extra_features`.
+ *
+ * @param {object} note - The note: `file`, `raw` and parsed `fm`.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} look - The
+ *   being-look vocabulary.
+ * @returns {object[]} Error findings, each located at the entry at fault.
+ */
+export function checkExtraFeatures(note: object, look: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): object[];
+/**
+ * Hair and eye colour spellings the vocabulary does not take but an author
+ * writes, as regular-expression alternatives. Beside `hair` or `eyes` any of
+ * them, or any hair or eye colour word, states a colour.
+ */
+export const COLOUR_VARIANTS: readonly string[];
+/**
+ * Skin-condition phrasings that are not complexion words, as
+ * regular-expression alternatives. Any of them states a complexion.
+ */
+export const CONDITION_PHRASES: readonly string[];
+/**
+ * The terms that make an `extra_features` entry something other than a
+ * physical mark, by category, as case-insensitive whole-word patterns.
+ *
+ * `exemptMarks` lets an entry describing a tattoo, scar, brand or burn mark
+ * pass the category, so "a tattoo of a knight's helmet" stands while "wears a
+ * helmet" does not. The voice, impression, handedness, sterility and age
+ * categories admit no such exemption: "a beautiful tattoo of a crane" is
+ * refused.
+ *
+ * @type {ReadonlyArray<{rule: string, category: string, pattern: RegExp, exemptMarks: boolean}>}
+ */
+export const NON_PHYSICAL_FEATURES: ReadonlyArray<{
+    rule: string;
+    category: string;
+    pattern: RegExp;
+    exemptMarks: boolean;
+}>;

package/types/engine/culture-parents.d.mts

@@ -0,0 +1,29 @@
+/** The authored source of one inherited field, retained outside the published record. */
+export function cultureFieldSource(records: any, key: any, field: any): any;
+/** Fields supplied by an ancestor rather than authored on this record. */
+export function cultureInheritedFields(record: any): any;
+/** Read the hierarchy findings retained beside a resolved index record. */
+export function cultureRecordProblems(record: any): any;
+/** Read hierarchy findings attached to one culture's resolved index record. */
+export function cultureHierarchyProblems(records: any, key: any): any;
+/**
+ * Check the declared culture-parent field in the normal frontmatter lint.
+ * @param {object} note - The note's frontmatter and source location.
+ * @param {{index?: object}} [options] - The corpus and its Address lookup.
+ * @returns {object[]} Located findings.
+ */
+export function checkCultureParents(note: object, { index }?: {
+    index?: object;
+}): object[];
+/**
+ * Resolve each omitted culture field independently, searching parents in listed depth-first order.
+ * Same-depth disagreement withholds the inherited field and produces a finding.
+ * @param {object} index - The authored culture nodes and Address lookup.
+ * @returns {{values: Map<object, object>, findings: object[]}}
+ */
+export function cultureInheritance(index: object): {
+    values: Map<object, object>;
+    findings: object[];
+};
+/** Emit or collect all findings from culture inheritance. */
+export function reportCultureParents(findings: any, problems: any): void;

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

@@ -60,7 +60,8 @@ export function mapEntriesOf(value: unknown): Array<[string, unknown]>;
  *
  * @param {readonly object[]} fields - The type's `data:` declaration.
  * @returns {object[]} One spec per top-level key, a dotted group as a `map`
- *   whose `fields` are its members, with `grouped: true`.
+ *   whose `fields` are its members, with `grouped: true`, and each member
+ *   marked `kindChecked`.
  */
 export function topLevelSpecs(fields: readonly object[]): object[];
 /**

package/types/engine/docs-checks.d.mts

@@ -1,5 +1,5 @@
 /** Preserve offsets while excluding literal examples from link scanning. */
-export function maskMarkdownCode(source: any, spans?: boolean): any;
+export function maskMarkdownCode(source: any, spans?: boolean): string;
 /** GitHub heading slug, retaining separate spaces after punctuation removal. */
 export function docHeadingSlug(value: any): any;
 /** @param {string} source */

package/types/engine/note-vocabulary.d.mts

@@ -136,9 +136,9 @@ export function subTypes(type: string, vocabulary?: Readonly<Record<string, Type
  *
  * Each field is closed to its list: any other value, an empty one included, is
  * a finding at the value naming the words it takes. `appearance.complexion`
- * takes one word or a list of them, and each entry is checked on its own.
- * `appearance.extra_features` is not here: it is free text, a list of the marks
- * no word covers.
+ * is a list of words, each entry checked on its own. `appearance.extra_features`
+ * is not here: it is a list of the physical marks no word covers, held to the
+ * rules of `appearance-features.mjs`.
  *
  * @type {Readonly<Record<string, readonly LookWord[]>>}
  */