@heroiclands/package-build 20.6.0 → 21.0.0

package/types/sohl/infobox.d.mts

@@ -0,0 +1,145 @@
+/**
+ * What one entry of `sohl.items` names.
+ *
+ * An entry addresses its item three ways and every tree uses all three: a
+ * `model` address whose last two hyphen-separated segments are always
+ * `<type>-<shortcode>`, explicit `type` / `shortcode` keys, or a locally
+ * authored item stating its type with the shortcode inside its own `system`
+ * block. One decode covers all of them, so nothing downstream has to know
+ * which form a note happened to use.
+ *
+ * @param {object} entry - One `sohl.items` entry.
+ * @returns {{type: string, shortcode: string, name: string, system: object}|undefined}
+ *   What it names, or `undefined` when it names nothing addressable.
+ */
+export function decodeItem(entry: object): {
+    type: string;
+    shortcode: string;
+    name: string;
+    system: object;
+} | undefined;
+/**
+ * A being's box: attributes, skills, mystical abilities and equipment.
+ *
+ * Each is a section of its own, because a section is the unit that flows — the
+ * panel breaks between `ATTRIBUTES` and `SKILLS` rather than through either.
+ * A section with nothing in it is not emitted at all, which is what makes a
+ * sparse creature's box short rather than mostly empty.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} ctx - `{ block, resolve }`.
+ * @returns {object[]} The sections.
+ */
+export function beingSections(fm: object, { block, resolve }: object): object[];
+/**
+ * Armour's box: whatever the note states, then the protection it gives.
+ *
+ * Protection is shown whole, with an aspect nobody stated rendered `0`. Armour
+ * that stops nothing edged is a fact about the armour, and dropping the row
+ * would leave a reader to guess whether it was unstated or nil.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} ctx - The section context.
+ * @returns {object[]} The sections.
+ */
+export function armorSections(fm: object, ctx: object): object[];
+/**
+ * A weapon's box: whatever the note states, then one line per strike mode.
+ *
+ * A mode that states no attack modifier, no impact or no length is shown with
+ * {@link UNSTATED} in that place rather than with the clause missing: the
+ * modes are read against each other, and a line that is shorter than its
+ * neighbour for no visible reason reads as a fault.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} ctx - The section context.
+ * @returns {object[]} The sections.
+ */
+export function weaponSections(fm: object, ctx: object): object[];
+/**
+ * A projectile's box: whatever the note states, then what it hits for.
+ *
+ * Impact is three declared fields — dice, modifier and aspect — and a reader
+ * wants the one quantity they compose into. Three rows reading `Die 6`,
+ * `Modifier 2`, `Aspect Piercing` say the declaration's structure rather than
+ * the projectile's, so the three are withheld and the row they make is added
+ * in their place.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} ctx - The section context.
+ * @returns {object[]} The sections.
+ */
+export function projectileSections(fm: object, ctx: object): object[];
+/**
+ * A weapon's strike modes, whichever of the two shapes the note wrote.
+ *
+ * Both are live in the corpus and both name the same thing. A **list** carries
+ * the mode's identity inside it, as `shortcode`, which is the shape a
+ * compendium document holds; a **mapping** carries it as the key. So the
+ * fallback name comes from the shortcode in one and from the key in the other,
+ * and everything downstream sees one shape.
+ *
+ * @param {unknown} declared - What the note wrote at `strikeModes`.
+ * @returns {[string, object][]} Mode name → the mode.
+ */
+export function strikeModes(declared: unknown): [string, object][];
+/** What this system's box is called. @type {string} */
+export const SOHL_INFOBOX_TITLE: string;
+/**
+ * What a value nobody stated is shown as, where showing nothing would be the
+ * wrong answer.
+ *
+ * Rule 4 drops an absent field, and that is right almost everywhere. It is
+ * wrong in a table of strike modes, where a column left blank on one row and
+ * filled on the next reads as a rendering fault rather than as a weapon that
+ * cannot be used that way.
+ *
+ * @type {string}
+ */
+export const UNSTATED: string;
+/**
+ * The declarations of the four aspects armour is rated against, in the order a
+ * sheet shows them.
+ *
+ * Taken from the armour field declaration rather than listed: the declaration
+ * names `protection.blunt`, `protection.edged` and the rest, so the set, its
+ * order **and where each is authored** come from the same place the compiler
+ * reads them. Carrying the whole declaration rather than the aspect's word is
+ * what lets the grid resolve a value the way the compiler does — a note writes
+ * `sohl.system.protectionBase.blunt`, and a grid that read the declared
+ * *source* path instead would find nothing and call every aspect unstated.
+ *
+ * @type {readonly object[]}
+ */
+export const PROTECTION_FIELDS: readonly object[];
+/**
+ * SoHL's presentation overlay: what one of this system's fields is called, and
+ * the few that carry no row.
+ *
+ * **Not a second field list.** The fields come from {@link NOTE_SCHEMAS}, and
+ * a field this overlay does not mention still gets a row under its own
+ * humanised name — so a field added to a type reaches the box with no edit
+ * here. What the overlay adds is the two things a compiler's field list cannot
+ * say, because they are about a page rather than about a document:
+ *
+ * - **a reader's word** where the declaration's key is the compiler's. A key
+ *   is named for the value it carries into a DataModel; `assocSkillCode` and
+ *   `perceptionPenaltyBase` are exactly right there and wrong in a panel
+ *   somebody reads.
+ * - **which facts belong on a page at all.** A value shown whole somewhere
+ *   else in the same box — protection, strike modes, a projectile's impact —
+ *   would otherwise be said twice, the second time a row at a time and worse;
+ *   and a flag that steers a character sheet is not a fact about the subject.
+ *
+ * @type {Readonly<Record<string, {label?: string, withheld?: string}>>}
+ */
+export const SOHL_FIELD_PRESENTATION: Readonly<Record<string, {
+    label?: string;
+    withheld?: string;
+}>>;
+/**
+ * SoHL's infobox declaration.
+ *
+ * @type {object}
+ */
+export const SOHL_INFOBOX: object;