Hankan/lib/blocks.js

/* The block protocol — how 선생님 drives the UI.
   The tutor writes prose plus fenced blocks; the client renders them
   as real interface and sends structured answers back. */

const RE = {
  task:     /::task\s+(translate|match|build|choice)\s*\n([\s\S]*?)(?:\n::|$)/,
  words:    /::words\s*\n([\s\S]*?)(?:\n::|$)/,
  gloss:    /::gloss\s*\n([\s\S]*?)(?:\n::|$)/,
  progress: /::progress\s+(\d{1,3})\s*(?:\|\s*([^\n]*))?/,
};
const rows = s => s.split("\n").map(l => l.trim()).filter(l => l && !/^::/.test(l));
const cols = l => l.split("|").map(x => x.trim());

export function parse(text) {
  const w = text.match(RE.words), t = text.match(RE.task);
  const g = text.match(RE.gloss), p = text.match(RE.progress);

  const words = w ? rows(w[1]).map(l => { const c = cols(l);
      return { ko: c[0], gloss: c[1] || "", note: c[2] || "" }; }) : null;

  let task = null;
  if (t) {
    const r = rows(t[2]);
    if (t[1] === "translate") task = { type: "translate", items: r.map(q => ({ q })) };
    if (t[1] === "match")     task = { type: "match", pairs: r.map(l => { const c = cols(l);
                                        return { ko: c[0], gloss: c[1] }; }).filter(x => x.ko && x.gloss) };
    if (t[1] === "build")     task = { type: "build", items: r.map(l => { const c = cols(l);
                                        return { en: c[0], chips: c.slice(1).filter(Boolean) }; }).filter(x => x.en && x.chips.length) };
    if (t[1] === "choice")    task = { type: "choice", items: r.map(l => { const c = cols(l);
                                        return { q: c[0], options: c.slice(1).filter(Boolean) }; }).filter(x => x.q && x.options.length > 1) };
  }

  let gloss = null;
  if (g) {
    const blocks = []; let cur = null;
    g[1].split("\n").forEach(line => {
      const l = line.trim();
      if (!l || /^::/.test(l)) return;
      if (l.startsWith("=")) { if (cur) cur.en = l.slice(1).trim(); return; }
      const c = cols(l);
      if (!cur) { cur = { parts: [], en: "" }; blocks.push(cur); }
      cur.parts.push({ ko: c[0], role: (c[1] || "N").toUpperCase()[0], gloss: c[2] || "", highlight: c[3] || "" });
    });
    const keep = blocks.filter(b => b.parts.length);
    if (keep.length) gloss = keep;
  }

  let body = text;
  if (p) body = body.replace(p[0], "");
  if (g) body = body.replace(g[0], "");
  if (w) body = body.slice(0, body.indexOf("::words") >= 0 ? body.indexOf("::words") : body.length);
  if (t) body = body.replace(t[0], "");

  return {
    body: body.replace(/\n{3,}/g, "\n\n").trim(),
    words, task, gloss,
    progress: p ? { score: Math.max(0, Math.min(100, +p[1])), note: (p[2] || "").trim() } : null,
  };
}

/** Roles a gloss part can carry, and what the UI should do with each. */
export const ROLES = {
  S: "주어 subject",      T: "주제 topic",       O: "목적어 object",
  V: "서술어 predicate",  P: "자리·때 place/time", C: "이음 connective",
  Q: "인용 quotation",    M: "수식 modifier",    N: "",
};

/** Turn a completed task back into the message the student sends. */
export function answerText(task, state, lookups = []) {
  let body;
  if (task.type === "translate")
    body = "My answers:\n" + task.items.map((it, i) =>
      `${it.q} → ${(state[i] || "").trim() || "(not sure)"}`).join("\n");
  else if (task.type === "match")
    body = "My pairings:\n" + (state.pairs.map(p => `${p.ko} = ${p.gloss}`).join("\n") || "(none)");
  else if (task.type === "build")
    body = "My sentences:\n" + task.items.map((it, i) =>
      `${it.en} → ${(state[i] || []).join(" ") || "(not sure)"}`).join("\n");
  else
    body = "My choices:\n" + task.items.map((it, i) =>
      `${it.q} → ${state[i] == null ? "(not sure)" : it.options[state[i]]}`).join("\n");

  return body + (lookups.length
    ? `\n\n(I had to look up: ${lookups.join(", ")})`
    : "\n\n(No lookups.)");
}