@tishlang/tishdoc-parse 0.1.0

package/src/meta_imports.tish

@@ -0,0 +1,89 @@
+// Optional frontmatter `imports` map: logical name → relative path string.
+// Expanded by prepending resolved file contents to the body before directive `::include` resolution.
+// Nested maps require JSON frontmatter today; minimal YAML is flat key/value only.
+
+fn metaImportsValue(meta) {
+  if (meta === null || typeof meta !== "object") {
+    return null
+  }
+  let ks = Object.keys(meta)
+  let i = 0
+  while (i < ks.length) {
+    if (ks[i] === "imports") {
+      return meta[ks[i]]
+    }
+    i = i + 1
+  }
+  return null
+}
+
+export fn applyMetaImportsToBody(meta, body, readPartial, allDiag) {
+  let b = body
+  if (b === null) {
+    b = ""
+  }
+  if (typeof b !== "string") {
+    b = String(b)
+  }
+  let im = metaImportsValue(meta)
+  if (im === null || typeof im !== "object") {
+    let r0 = {}
+    r0["body"] = b
+    return r0
+  }
+  if (Array.isArray(im)) {
+    let d0 = {}
+    d0["level"] = "warn"
+    d0["message"] = "meta imports: expected object map, got array — ignored"
+    allDiag.push(d0)
+    let r1 = {}
+    r1["body"] = b
+    return r1
+  }
+  if (readPartial === null) {
+    let d1 = {}
+    d1["level"] = "warn"
+    d1["message"] = "meta imports present but readPartial is null — imports not expanded"
+    allDiag.push(d1)
+    let r2 = {}
+    r2["body"] = b
+    return r2
+  }
+  let keys = Object.keys(im)
+  let prep = ""
+  let ki = 0
+  while (ki < keys.length) {
+    let logical = keys[ki]
+    let pathVal = im[logical]
+    if (typeof pathVal !== "string") {
+      let dw = {}
+      dw["level"] = "warn"
+      dw["message"] = "meta imports." + String(logical) + ": expected string path"
+      allDiag.push(dw)
+      ki = ki + 1
+      continue
+    }
+    let content = readPartial(pathVal)
+    if (content === null) {
+      let de = {}
+      de["level"] = "error"
+      de["message"] = "meta imports." + String(logical) + ": not found " + String(pathVal)
+      allDiag.push(de)
+      ki = ki + 1
+      continue
+    }
+    let chunk = typeof content === "string" ? content : String(content)
+    if (prep.length > 0) {
+      prep = prep + "\n"
+    }
+    prep = prep + chunk
+    ki = ki + 1
+  }
+  let out = b
+  if (prep.length > 0) {
+    out = prep + "\n\n" + b
+  }
+  let rf = {}
+  rf["body"] = out
+  return rf
+}

package/src/parse_blocks.tish

@@ -0,0 +1,434 @@
+import { trim } from "./trim.tish"
+import {
+  headingNode,
+  paragraphNode,
+  listNode,
+  listItemNode,
+  codeBlockNode,
+  directiveBlockNode,
+  directiveLeafNode,
+  includeNode,
+  blockQuoteNode,
+  thematicBreakNode,
+  orderedListNode,
+  tableNode,
+  tableCellNode
+} from "./ast.tish"
+import { parseDirectiveAttrs } from "./attrs.tish"
+import { parseInlineSegments } from "./inline.tish"
+
+// True if a line is an entire ASCII run of `c` (length >= 3), optionally with
+// spaces between. Used for thematic breaks `---`, `***`, `___`.
+fn isThematicBreak(t) {
+  if (t.length < 3) { return false }
+  let c0 = t.charAt(0)
+  if (c0 !== "-" && c0 !== "*" && c0 !== "_") { return false }
+  let count = 0
+  let i = 0
+  while (i < t.length) {
+    let c = t.charAt(i)
+    if (c === c0) { count = count + 1 }
+    else if (c !== " " && c !== "\t") { return false }
+    i = i + 1
+  }
+  return count >= 3
+}
+
+// Detect ordered-list item: e.g. "1. Item", "12) Item". Returns
+// { start, body } if it matches, else null.
+fn matchOrderedListItem(t) {
+  if (t.length === 0) { return null }
+  let i = 0
+  while (i < t.length) {
+    let c = t.charAt(i)
+    if (c < "0" || c > "9") { break }
+    i = i + 1
+  }
+  if (i === 0) { return null }
+  if (i >= t.length) { return null }
+  let punct = t.charAt(i)
+  if (punct !== "." && punct !== ")") { return null }
+  if ((i + 1) >= t.length) { return null }
+  if (t.charAt(i + 1) !== " ") { return null }
+  let r = {}
+  r["start"] = parseInt(t.slice(0, i))
+  r["body"] = trim(t.slice(i + 2))
+  return r
+}
+
+// Parse a GFM table delimiter row like `| --- | :---: | ---: |` and return
+// an array of alignment strings ("left" | "center" | "right" | "default")
+// or null if the line isn't a delimiter row.
+fn parseTableDelimiter(t) {
+  let s = t
+  if (s.charAt(0) === "|") { s = s.slice(1) }
+  if (s.length > 0 && s.charAt(s.length - 1) === "|") { s = s.slice(0, s.length - 1) }
+  let cells = s.split("|")
+  let aligns = []
+  let i = 0
+  while (i < cells.length) {
+    let cell = trim(cells[i])
+    if (cell.length === 0) { return null }
+    let left = false
+    let right = false
+    if (cell.charAt(0) === ":") { left = true; cell = cell.slice(1) }
+    if (cell.length > 0 && cell.charAt(cell.length - 1) === ":") { right = true; cell = cell.slice(0, cell.length - 1) }
+    if (cell.length === 0) { return null }
+    let j = 0
+    while (j < cell.length) {
+      if (cell.charAt(j) !== "-") { return null }
+      j = j + 1
+    }
+    if (left && right) { aligns.push("center") }
+    else if (right) { aligns.push("right") }
+    else if (left) { aligns.push("left") }
+    else { aligns.push("default") }
+    i = i + 1
+  }
+  if (aligns.length === 0) { return null }
+  return aligns
+}
+
+// Collect a contiguous run of ordered-list items starting at `lines[i]`.
+// Returns { start, items, nextI } so the caller never needs to keep
+// intermediate `let`s around (Tish JS backend block-scopes nested lets).
+fn collectOrderedListPack(lines, i) {
+  let first = matchOrderedListItem(lines[i].trim())
+  let items = []
+  items.push(listItemNode(parseInlineSegments(first["body"])))
+  let j = i + 1
+  while (j < lines.length) {
+    let Lo = lines[j].trim()
+    if (Lo === "") { break }
+    let nx = matchOrderedListItem(Lo)
+    if (nx === null) { break }
+    items.push(listItemNode(parseInlineSegments(nx["body"])))
+    j = j + 1
+  }
+  let r = {}
+  r["start"] = first["start"]
+  r["items"] = items
+  r["nextI"] = j
+  return r
+}
+
+// True if `lines[i]` could be a GFM table header (contains a `|`) and
+// `lines[i+1]` is a parseable delimiter row whose column count matches.
+// Pulled out into a helper because Tish's JS backend block-scopes nested
+// `let` declarations, which made the inline form ReferenceError at runtime.
+fn canStartGfmTable(lines, i, t) {
+  if (t.indexOf("|") < 0) { return false }
+  if ((i + 1) >= lines.length) { return false }
+  let next = lines[i + 1].trim()
+  if (next.indexOf("-") < 0 || next.indexOf("|") < 0) { return false }
+  let aligns = parseTableDelimiter(next)
+  if (aligns === null) { return false }
+  let header = splitTableRow(t)
+  if (header.length !== aligns.length) { return false }
+  return true
+}
+
+// Split a table row into trimmed cell strings (handles optional leading /
+// trailing pipes; ignores escaped pipes \|).
+fn splitTableRow(t) {
+  let s = t
+  if (s.length > 0 && s.charAt(0) === "|") { s = s.slice(1) }
+  if (s.length > 0 && s.charAt(s.length - 1) === "|") { s = s.slice(0, s.length - 1) }
+  let cells = []
+  let buf = ""
+  let i = 0
+  while (i < s.length) {
+    let c = s.charAt(i)
+    if (c === "\\" && (i + 1) < s.length && s.charAt(i + 1) === "|") {
+      buf = buf + "|"
+      i = i + 2
+      continue
+    }
+    if (c === "|") {
+      cells.push(trim(buf))
+      buf = ""
+      i = i + 1
+      continue
+    }
+    buf = buf + c
+    i = i + 1
+  }
+  cells.push(trim(buf))
+  return cells
+}
+
+fn parseDirectiveOpenLine(t) {
+  let rest = t.slice(3).trim()
+  let nameEnd = 0
+  while (nameEnd < rest.length) {
+    let ch = rest.charAt(nameEnd)
+    if (ch === " " || ch === "\t" || ch === "{") {
+      break
+    }
+    nameEnd = nameEnd + 1
+  }
+  let name = trim(rest.slice(0, nameEnd))
+  let after = trim(rest.slice(nameEnd))
+  let attrs = {}
+  if (after.startsWith("{")) {
+    attrs = parseDirectiveAttrs(after.slice(after.indexOf("{")))
+  }
+  let p = {}
+  p["name"] = name
+  p["attrs"] = attrs
+  return p
+}
+
+export fn isBlockStart(t) {
+  if (t.startsWith("#")) {
+    return true
+  }
+  if (t.startsWith("```")) {
+    return true
+  }
+  if (t.startsWith(":::")) {
+    return true
+  }
+  if (t.startsWith("::") && !t.startsWith(":::")) {
+    return true
+  }
+  if (t.startsWith("- ") || t.startsWith("* ")) {
+    return true
+  }
+  if (t.startsWith("> ") || t === ">") {
+    return true
+  }
+  if (matchOrderedListItem(t) !== null) {
+    return true
+  }
+  if (isThematicBreak(t)) {
+    return true
+  }
+  return false
+}
+
+fn parseMarkdownToBlocksInner(body) {
+  let children = []
+  if (body === null) {
+    return children
+  }
+  let lines = (typeof body === "string" ? body : String(body)).split("\n")
+  let i = 0
+  let directiveStack = []
+
+  while (i < lines.length) {
+    let line = lines[i]
+    let t = line.trim()
+
+    if (t === "") {
+      i = i + 1
+      continue
+    }
+
+    if (directiveStack.length > 0) {
+      if (t === ":::") {
+        let frame = directiveStack.pop()
+        let innerBody = frame.lines.join("\n")
+        let innerBlocks = parseMarkdownToBlocksInner(innerBody)
+        if (frame.name === "include") {
+          let p = frame.attrs.path
+          if (p === null) {
+            p = ""
+          }
+          children.push(includeNode(String(p), true, null, innerBlocks))
+        } else {
+          children.push(directiveBlockNode(frame.name, frame.attrs, innerBlocks))
+        }
+        i = i + 1
+        continue
+      }
+      if (t.startsWith(":::")) {
+        let parsed = parseDirectiveOpenLine(t)
+        let fr = {}
+        fr.name = parsed.name
+        fr.attrs = parsed.attrs
+        fr.lines = []
+        directiveStack.push(fr)
+        i = i + 1
+        continue
+      }
+      let top = directiveStack[directiveStack.length - 1]
+      top.lines.push(line)
+      i = i + 1
+      continue
+    }
+
+    if (t.startsWith("```")) {
+      let lang = t.slice(3).trim()
+      let acc = []
+      i = i + 1
+      while (i < lines.length) {
+        let L = lines[i]
+        if (L.trim() === "```") {
+          break
+        }
+        acc.push(L)
+        i = i + 1
+      }
+      if (i < lines.length) {
+        i = i + 1
+      }
+      children.push(codeBlockNode(lang, acc.join("\n")))
+      continue
+    }
+
+    if (t.startsWith(":::")) {
+      let parsed = parseDirectiveOpenLine(t)
+      let fr2 = {}
+      fr2.name = parsed.name
+      fr2.attrs = parsed.attrs
+      fr2.lines = []
+      directiveStack.push(fr2)
+      i = i + 1
+      continue
+    }
+
+    if (t.startsWith("::") && !t.startsWith(":::")) {
+      let rest = t.slice(2).trim()
+      let nameEnd = 0
+      while (nameEnd < rest.length) {
+        let ch2 = rest.charAt(nameEnd)
+        if (ch2 === "{" || ch2 === " " || ch2 === "\t") {
+          break
+        }
+        nameEnd = nameEnd + 1
+      }
+      let dname = trim(rest.slice(0, nameEnd))
+      let after2 = trim(rest.slice(nameEnd))
+      let attrs2 = {}
+      if (after2.startsWith("{")) {
+        attrs2 = parseDirectiveAttrs(after2)
+      }
+      if (dname === "include") {
+        let p = attrs2.path
+        if (p === null) {
+          p = ""
+        }
+        children.push(includeNode(String(p), false, "unresolved leaf include; expand source with readPartial or use :::include", []))
+      } else {
+        children.push(directiveLeafNode(dname, attrs2))
+      }
+      i = i + 1
+      continue
+    }
+
+    if (t.startsWith("#")) {
+      let level = 0
+      let k = 0
+      while (k < t.length && t.charAt(k) === "#") {
+        level = level + 1
+        k = k + 1
+      }
+      if (level > 6) {
+        level = 6
+      }
+      let title = trim(t.slice(k))
+      children.push(headingNode(level, parseInlineSegments(title)))
+      i = i + 1
+      continue
+    }
+
+    if (t.startsWith("- ") || t.startsWith("* ")) {
+      let items = []
+      while (i < lines.length) {
+        let L3 = lines[i].trim()
+        if (L3 === "") {
+          break
+        }
+        if (!L3.startsWith("- ") && !L3.startsWith("* ")) {
+          break
+        }
+        let itemText = trim(L3.slice(2))
+        items.push(listItemNode(parseInlineSegments(itemText)))
+        i = i + 1
+      }
+      children.push(listNode(false, items))
+      continue
+    }
+
+    if (matchOrderedListItem(t) !== null) {
+      let pack = collectOrderedListPack(lines, i)
+      children.push(orderedListNode(pack["start"], pack["items"]))
+      i = pack["nextI"]
+      continue
+    }
+
+    if (t.startsWith("> ") || t === ">") {
+      let qbuf = []
+      while (i < lines.length) {
+        let Lq = lines[i]
+        let Tq = Lq.trim()
+        if (Tq === "") { break }
+        if (Tq.startsWith("> ")) { qbuf.push(Tq.slice(2)) }
+        else if (Tq === ">") { qbuf.push("") }
+        else { break }
+        i = i + 1
+      }
+      let inner = parseMarkdownToBlocksInner(qbuf.join("\n"))
+      children.push(blockQuoteNode(inner))
+      continue
+    }
+
+    if (isThematicBreak(t)) {
+      children.push(thematicBreakNode())
+      i = i + 1
+      continue
+    }
+
+    if (canStartGfmTable(lines, i, t)) {
+      let aligns = parseTableDelimiter(lines[i + 1].trim())
+      let headerCells = splitTableRow(t)
+      let headerNodes = []
+      let hi = 0
+      while (hi < headerCells.length) {
+        headerNodes.push(tableCellNode(parseInlineSegments(headerCells[hi])))
+        hi = hi + 1
+      }
+      let rows = []
+      i = i + 2
+      while (i < lines.length) {
+        let Lt = lines[i].trim()
+        if (Lt === "" || Lt.indexOf("|") < 0) { break }
+        let cells = splitTableRow(Lt)
+        let cellNodes = []
+        let ci3 = 0
+        while (ci3 < cells.length) {
+          cellNodes.push(tableCellNode(parseInlineSegments(cells[ci3])))
+          ci3 = ci3 + 1
+        }
+        rows.push(cellNodes)
+        i = i + 1
+      }
+      children.push(tableNode(aligns, headerNodes, rows))
+      continue
+    }
+
+    let para = []
+    while (i < lines.length) {
+      let L4 = lines[i]
+      if (L4.trim() === "") {
+        break
+      }
+      if (isBlockStart(L4.trim())) {
+        break
+      }
+      para.push(L4)
+      i = i + 1
+    }
+    if (para.length > 0) {
+      let ptext = para.join("\n")
+      children.push(paragraphNode(parseInlineSegments(ptext)))
+    }
+  }
+
+  return children
+}
+
+export fn parseMarkdownToBlocks(body) {
+  return parseMarkdownToBlocksInner(body)
+}

package/src/trim.tish

@@ -0,0 +1,21 @@
+// Shared whitespace trim for bundled JS (duplicate `trim` top-level names break `tish build --target js`).
+
+export fn trim(s) {
+  let a = 0
+  let b = s.length
+  while (a < b) {
+    let c = s.charAt(a)
+    if (c !== " " && c !== "\t" && c !== "\r" && c !== "\n") {
+      break
+    }
+    a = a + 1
+  }
+  while (b > a) {
+    let c2 = s.charAt(b - 1)
+    if (c2 !== " " && c2 !== "\t" && c2 !== "\r" && c2 !== "\n") {
+      break
+    }
+    b = b - 1
+  }
+  return s.slice(a, b)
+}

package/src/validate_meta.tish

@@ -0,0 +1,118 @@
+// Well-known meta keys; optional strict mode.
+// Missing keys: direct `obj["k"]` throws in Tish — use safeGet for optional fields.
+
+fn safeGet(obj, key) {
+  let ks = Object.keys(obj)
+  let i = 0
+  while (i < ks.length) {
+    if (ks[i] === key) {
+      return obj[ks[i]]
+    }
+    i = i + 1
+  }
+  return null
+}
+
+fn diag(level, message) {
+  let d = {}
+  d["level"] = level
+  d["message"] = message
+  return d
+}
+
+export fn validateMeta(meta, options) {
+  let diagnostics = []
+  if (meta === null || typeof meta !== "object") {
+    let r = {}
+    r["diagnostics"] = diagnostics
+    return r
+  }
+  let strict = false
+  if (options !== null && safeGet(options, "strictMeta") === true) {
+    strict = true
+  }
+
+  let keys = Object.keys(meta)
+  let ki = 0
+  while (ki < keys.length) {
+    let k = keys[ki]
+    if (!isKnownMetaKey(k)) {
+      if (strict) {
+        diagnostics.push(diag("error", "Unknown meta key (strict): " + k))
+      } else {
+        diagnostics.push(diag("warn", "Unknown meta key: " + k))
+      }
+    }
+    ki = ki + 1
+  }
+
+  let dt = safeGet(meta, "doc_type")
+  if (dt === null) {
+    dt = safeGet(meta, "kind")
+  }
+  if (dt !== null && String(dt) !== "") {
+    if (!isKnownDocType(String(dt))) {
+      diagnostics.push(diag("warn", "Unknown doc_type/kind: " + String(dt) + " (expected note|deck|resume|whitepaper)"))
+    }
+  }
+
+  let r2 = {}
+  r2["diagnostics"] = diagnostics
+  return r2
+}
+
+fn isKnownMetaKey(k) {
+  if (k === "title") {
+    return true
+  }
+  if (k === "description") {
+    return true
+  }
+  if (k === "doc_type") {
+    return true
+  }
+  if (k === "kind") {
+    return true
+  }
+  if (k === "theme") {
+    return true
+  }
+  if (k === "layout") {
+    return true
+  }
+  if (k === "author") {
+    return true
+  }
+  if (k === "date") {
+    return true
+  }
+  if (k === "tags") {
+    return true
+  }
+  if (k === "imports") {
+    return true
+  }
+  if (k === "export") {
+    return true
+  }
+  if (k === "pdf") {
+    return true
+  }
+  return false
+}
+
+fn isKnownDocType(dt) {
+  if (dt === "note") {
+    return true
+  }
+  if (dt === "deck") {
+    return true
+  }
+  if (dt === "resume") {
+    return true
+  }
+  if (dt === "whitepaper") {
+    return true
+  }
+  return false
+}

package/src/yaml_simple.tish

@@ -0,0 +1,46 @@
+// Minimal YAML subset: flat `key: value` lines; `#` comments; quoted values.
+
+import { trim } from "./trim.tish"
+
+export fn parseSimpleYamlBlock(text) {
+  let out = {}
+  let lines = text.split("\n")
+  let i = 0
+  while (i < lines.length) {
+    let line = lines[i]
+    let t = trim(line)
+    if (t === "" || t.charAt(0) === "#") {
+      i = i + 1
+      continue
+    }
+    let colon = t.indexOf(":")
+    if (colon <= 0) {
+      throw new Error("Unsupported YAML line (expected key: value): " + t)
+    }
+    let key = trim(t.slice(0, colon))
+    let rest = trim(t.slice(colon + 1))
+    if (key === "") {
+      throw new Error("Empty YAML key")
+    }
+    if (rest.charAt(0) === "\"" && rest.charAt(rest.length - 1) === "\"") {
+      out[key] = rest.slice(1, rest.length - 1)
+    } else if (rest.charAt(0) === "'" && rest.charAt(rest.length - 1) === "'") {
+      out[key] = rest.slice(1, rest.length - 1)
+    } else if (rest === "true") {
+      out[key] = true
+    } else if (rest === "false") {
+      out[key] = false
+    } else if (rest === "null") {
+      out[key] = null
+    } else {
+      let n = parseFloat(rest)
+      if (!isNaN(n) && String(n) === rest) {
+        out[key] = n
+      } else {
+        out[key] = rest
+      }
+    }
+    i = i + 1
+  }
+  return out
+}