scripts/lib/frontmatter.js

'use strict';
/**
 * frontmatter.js — minimal YAML-frontmatter reader for the Nomad scripts/ package.
 *
 * This is NOT a general YAML parser, and deliberately narrower than the
 * production structure-sentinel parser it is conceptually descended from
 * (that one also parses tags arrays and links object-arrays; those tools are
 * not part of this portable package). This module only answers the questions
 * frontmatter-touch.js needs:
 *
 *   1. Does this file open with a complete `--- ... ---` frontmatter block?
 *   2. What are the block's COLUMN-ZERO scalar fields (`key: value`)?
 *   3. On which physical line does a given scalar field sit (for surgical
 *      single-line replace/insert that never reflows the rest of the file)?
 *
 * Scope decisions (all deliberate):
 *   - Only column-zero `key: value` lines count as scalar fields. Indented
 *     lines (e.g. the `  target: ...` rows inside a `links:` object-array)
 *     are structurally ignored — this makes it impossible to mistake a
 *     nested mapping value for a top-level field, without needing to
 *     understand the nested structure at all.
 *   - Unknown/unparsable lines are skipped, never fatal — same tolerance
 *     contract as the production parser: one odd line must not make the
 *     whole file unreadable to tooling.
 *   - BOM-aware (Windows editors routinely add one; charter-style files in
 *     the wild have it) and newline-style preserving: parsing never
 *     normalizes anything, callers get enough position info to edit the
 *     original text losslessly.
 */

/**
 * Locate the frontmatter block. Returns null when the file doesn't open with
 * `---` on its first line; `{complete:false}` when the opening fence exists
 * but no closing fence was found (broken block — treat as unparseable).
 *
 * @param {string} content full file text (may carry a UTF-8 BOM)
 * @returns {null|{complete:boolean, blockLines:string[], headerLineCount:number, hasBom:boolean}}
 *   headerLineCount = number of physical lines from line 0 through the
 *   closing `---` fence inclusive (i.e. body starts at logical line index
 *   headerLineCount).
 */
function extractBlock(content) {
  if (typeof content !== 'string') return null;
  const hasBom = content.charCodeAt(0) === 0xfeff;
  const text = hasBom ? content.slice(1) : content;
  const lines = text.split(/\r\n|\r|\n/);
  if (lines[0] === undefined || lines[0].trim() !== '---') return null;
  for (let i = 1; i < lines.length; i++) {
    if (lines[i].trim() === '---') {
      return { complete: true, blockLines: lines.slice(1, i), headerLineCount: i + 1, hasBom };
    }
  }
  return { complete: false, blockLines: [], headerLineCount: 0, hasBom };
}

const SCALAR_LINE_RE = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/;

/**
 * Parse column-zero scalar fields out of a block's lines.
 * A line only counts when it starts at column zero (no leading whitespace) —
 * indented continuation/nested lines are ignored by design (see header).
 * First occurrence wins for duplicate keys (a duplicate is a file bug this
 * module has no business resolving; stable first-wins keeps edits predictable).
 *
 * @param {string[]} blockLines lines between the fences (exclusive)
 * @returns {{fields:Object.<string,string>, lineIndexByKey:Object.<string,number>}}
 *   lineIndexByKey values are indexes INTO blockLines (0-based).
 */
function parseScalarFields(blockLines) {
  const fields = {};
  const lineIndexByKey = {};
  for (let i = 0; i < blockLines.length; i++) {
    const line = blockLines[i];
    if (!line || /^\s/.test(line)) continue; // indented or empty — not a top-level scalar
    const m = line.match(SCALAR_LINE_RE);
    if (!m) continue;
    const key = m[1];
    if (Object.prototype.hasOwnProperty.call(fields, key)) continue; // first occurrence wins
    fields[key] = m[2].trim();
    lineIndexByKey[key] = i;
  }
  return { fields, lineIndexByKey };
}

/**
 * One-call convenience: block + scalar fields.
 * @returns {null|{complete:boolean, hasBom:boolean, headerLineCount:number,
 *   blockLines:string[], fields:Object, lineIndexByKey:Object}}
 */
function parse(content) {
  const block = extractBlock(content);
  if (!block) return null;
  if (!block.complete) {
    return { complete: false, hasBom: block.hasBom, headerLineCount: 0, blockLines: [], fields: {}, lineIndexByKey: {} };
  }
  const scalars = parseScalarFields(block.blockLines);
  return {
    complete: true,
    hasBom: block.hasBom,
    headerLineCount: block.headerLineCount,
    blockLines: block.blockLines,
    fields: scalars.fields,
    lineIndexByKey: scalars.lineIndexByKey,
  };
}

module.exports = {
  extractBlock,
  parseScalarFields,
  parse,
  SCALAR_LINE_RE,
};