@chanmeng666/archlang 0.1.0 → 0.2.0

package/dist/{chunk-J5DEA2KQ.js → chunk-ICYNEDSM.js}

@@ -19,11 +19,12 @@ function lex(src) {
     }
     return c;
   };
-  const push = (type, value, startLine, startCol, extra) => tokens.push({ type, value, line: startLine, col: startCol, ...extra });
+  const push = (type, value, startLine, startCol, startIdx, extra) => tokens.push({ type, value, line: startLine, col: startCol, ...extra, start: startIdx, end: i });
   while (i < src.length) {
     const c = peek();
     const startLine = line;
     const startCol = col;
+    const startIdx = i;
     if (c === " " || c === "	" || c === "\r" || c === "\n") {
       advance();
       continue;
@@ -53,50 +54,50 @@ function lex(src) {
         value += advance();
       }
       if (!terminated) {
-        errors.push({ message: "Unterminated string literal", line: startLine, col: startCol });
+        errors.push({ message: "Unterminated string literal", span: { start: startIdx, end: i } });
       }
-      push("string", value, startLine, startCol);
+      push("string", value, startLine, startCol, startIdx);
       continue;
     }
     if (c === "(") {
       advance();
-      push("lparen", "(", startLine, startCol);
+      push("lparen", "(", startLine, startCol, startIdx);
       continue;
     }
     if (c === ")") {
       advance();
-      push("rparen", ")", startLine, startCol);
+      push("rparen", ")", startLine, startCol, startIdx);
       continue;
     }
     if (c === "{") {
       advance();
-      push("lcurly", "{", startLine, startCol);
+      push("lcurly", "{", startLine, startCol, startIdx);
       continue;
     }
     if (c === "}") {
       advance();
-      push("rcurly", "}", startLine, startCol);
+      push("rcurly", "}", startLine, startCol, startIdx);
       continue;
     }
     if (c === ",") {
       advance();
-      push("comma", ",", startLine, startCol);
+      push("comma", ",", startLine, startCol, startIdx);
       continue;
     }
     if (c === "=") {
       advance();
-      push("equals", "=", startLine, startCol);
+      push("equals", "=", startLine, startCol, startIdx);
       continue;
     }
     if (c === ":") {
       advance();
-      push("colon", ":", startLine, startCol);
+      push("colon", ":", startLine, startCol, startIdx);
       continue;
     }
     if (c === "-" && peek(1) === ">") {
       advance();
       advance();
-      push("arrow", "->", startLine, startCol);
+      push("arrow", "->", startLine, startCol, startIdx);
       continue;
     }
     if (isDigit(c) || c === "-" && isDigit(peek(1)) || c === "." && isDigit(peek(1))) {
@@ -118,52 +119,67 @@ function lex(src) {
           while (isDigit(peek())) raw2 += advance();
         }
         const second = parseFloat(raw2);
-        push("dimension", `${raw}x${raw2}`, startLine, startCol, { num: first, num2: second });
+        push("dimension", `${raw}x${raw2}`, startLine, startCol, startIdx, { num: first, num2: second });
         continue;
       }
-      push("number", raw, startLine, startCol, { num: first });
+      push("number", raw, startLine, startCol, startIdx, { num: first });
       continue;
     }
     if (isIdentStart(c)) {
       let value = "";
       while (i < src.length && isIdentPart(peek())) value += advance();
-      push("ident", value, startLine, startCol);
+      push("ident", value, startLine, startCol, startIdx);
       continue;
     }
-    errors.push({ message: `Unexpected character ${JSON.stringify(c)}`, line: startLine, col: startCol });
+    errors.push({ message: `Unexpected character ${JSON.stringify(c)}`, span: { start: startIdx, end: startIdx + 1 } });
     advance();
   }
-  push("eof", "", line, col);
+  push("eof", "", line, col, i);
   return { tokens, errors };
 }
 
 // src/parser.ts
+var STATEMENT_STARTS = /* @__PURE__ */ new Set([
+  "units",
+  "grid",
+  "scale",
+  "north",
+  "wall",
+  "room",
+  "door",
+  "window",
+  "furniture",
+  "dim",
+  "title"
+]);
 var ParseError = class extends Error {
-  constructor(message, line, col) {
+  constructor(message, span) {
     super(message);
     this.message = message;
-    this.line = line;
-    this.col = col;
+    this.span = span;
   }
   message;
-  line;
-  col;
+  span;
 };
 function parse(src) {
   const { tokens, errors: lexErrors } = lex(src);
-  if (lexErrors.length > 0) {
-    return { errors: [lexErrors[0]] };
-  }
+  const lexDiags = lexErrors.map((e) => ({
+    severity: "error",
+    message: e.message,
+    span: e.span
+  }));
+  const p = new Parser(tokens);
+  let plan;
   try {
-    const p = new Parser(tokens);
-    const plan = p.parsePlan();
-    return { plan, errors: [] };
+    plan = p.parsePlan();
   } catch (e) {
     if (e instanceof ParseError) {
-      return { errors: [{ message: e.message, line: e.line, col: e.col }] };
+      p.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+    } else {
+      throw e;
     }
-    throw e;
   }
+  return { plan, diagnostics: [...lexDiags, ...p.diagnostics] };
 }
 var Parser = class {
   constructor(toks) {
@@ -171,6 +187,7 @@ var Parser = class {
   }
   toks;
   pos = 0;
+  diagnostics = [];
   peek(o = 0) {
     return this.toks[Math.min(this.pos + o, this.toks.length - 1)];
   }
@@ -178,7 +195,21 @@ var Parser = class {
     return this.toks[Math.min(this.pos++, this.toks.length - 1)];
   }
   fail(msg, t = this.peek()) {
-    throw new ParseError(msg, t.line, t.col);
+    throw new ParseError(msg, { start: t.start, end: t.end });
+  }
+  /** Span from a start offset to the end of the last consumed token. */
+  spanFrom(start) {
+    const last = this.toks[Math.max(0, Math.min(this.pos - 1, this.toks.length - 1))];
+    return { start, end: last.end };
+  }
+  /** Recover after a statement error: skip to the next statement start or block end. */
+  synchronize() {
+    if (!this.isType("rcurly") && !this.isType("eof")) this.next();
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const t = this.peek();
+      if (t.type === "ident" && STATEMENT_STARTS.has(t.value)) return;
+      this.next();
+    }
   }
   isKeyword(kw, o = 0) {
     const t = this.peek(o);
@@ -222,57 +253,96 @@ var Parser = class {
     };
     while (!this.isType("rcurly") && !this.isType("eof")) {
       const t = this.peek();
-      if (t.type !== "ident") this.fail(`Expected a statement but found ${describe(t)}`);
-      switch (t.value) {
-        case "units": {
-          this.next();
-          const u = this.eatIdent().value;
-          if (u !== "mm") this.fail(`Unsupported units "${u}" (only "mm" is supported)`, t);
-          plan.units = "mm";
-          break;
+      const start = t.start;
+      try {
+        if (t.type !== "ident") this.fail(`Expected a statement but found ${describe(t)}`);
+        switch (t.value) {
+          case "units": {
+            this.next();
+            const u = this.eatIdent().value;
+            if (u !== "mm") this.fail(`Unsupported units "${u}" (only "mm" is supported)`, t);
+            plan.units = "mm";
+            break;
+          }
+          case "grid":
+            this.next();
+            plan.grid = this.eatNumber();
+            break;
+          case "scale": {
+            this.next();
+            const a = this.eatNumber();
+            this.eat("colon");
+            const b = this.eatNumber();
+            plan.scale = `${a}:${b}`;
+            break;
+          }
+          case "north":
+            this.next();
+            plan.north = this.parseNorth();
+            break;
+          case "wall": {
+            const n = this.parseWall();
+            n.span = this.spanFrom(start);
+            plan.walls.push(n);
+            break;
+          }
+          case "room": {
+            const n = this.parseRoom();
+            n.span = this.spanFrom(start);
+            plan.rooms.push(n);
+            break;
+          }
+          case "door": {
+            const n = this.parseDoor();
+            n.span = this.spanFrom(start);
+            plan.doors.push(n);
+            break;
+          }
+          case "window": {
+            const n = this.parseWindow();
+            n.span = this.spanFrom(start);
+            plan.windows.push(n);
+            break;
+          }
+          case "furniture": {
+            const n = this.parseFurniture();
+            n.span = this.spanFrom(start);
+            plan.furniture.push(n);
+            break;
+          }
+          case "dim": {
+            const n = this.parseDim();
+            n.span = this.spanFrom(start);
+            plan.dims.push(n);
+            break;
+          }
+          case "title": {
+            const n = this.parseTitle();
+            n.span = this.spanFrom(start);
+            plan.title = n;
+            break;
+          }
+          default:
+            this.fail(`Unknown statement "${t.value}"`, t);
         }
-        case "grid":
-          this.next();
-          plan.grid = this.eatNumber();
-          break;
-        case "scale": {
-          this.next();
-          const a = this.eatNumber();
-          this.eat("colon");
-          const b = this.eatNumber();
-          plan.scale = `${a}:${b}`;
-          break;
+      } catch (e) {
+        if (e instanceof ParseError) {
+          this.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+          this.synchronize();
+        } else {
+          throw e;
         }
-        case "north":
-          this.next();
-          plan.north = this.parseNorth();
-          break;
-        case "wall":
-          plan.walls.push(this.parseWall());
-          break;
-        case "room":
-          plan.rooms.push(this.parseRoom());
-          break;
-        case "door":
-          plan.doors.push(this.parseDoor());
-          break;
-        case "window":
-          plan.windows.push(this.parseWindow());
-          break;
-        case "furniture":
-          plan.furniture.push(this.parseFurniture());
-          break;
-        case "dim":
-          plan.dims.push(this.parseDim());
-          break;
-        case "title":
-          plan.title = this.parseTitle();
-          break;
-        default:
-          this.fail(`Unknown statement "${t.value}"`, t);
       }
     }
-    this.eat("rcurly");
+    try {
+      this.eat("rcurly");
+    } catch (e) {
+      if (e instanceof ParseError) {
+        this.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+      } else {
+        throw e;
+      }
+    }
     return plan;
   }
   isType(type) {
@@ -561,8 +631,9 @@ function planBounds(plan) {
 
 // src/validate.ts
 function validate(plan) {
-  const errors = [];
-  const warnings = [];
+  const diags = [];
+  const error = (message, code, span) => diags.push({ severity: "error", message, code, span });
+  const warn = (message, code, span) => diags.push({ severity: "warning", message, code, span });
   const g = plan.grid;
   const snap = (v) => g > 0 ? Math.round(v / g) * g : v;
   const snapPt = (p) => ({ x: snap(p.x), y: snap(p.y) });
@@ -591,10 +662,10 @@ function validate(plan) {
     dm.to = snapPt(dm.to);
   }
   const seen = /* @__PURE__ */ new Set();
-  const assign = (provided, prefix, idx, line) => {
+  const assign = (provided, prefix, idx, span) => {
     if (provided) {
       if (seen.has(provided)) {
-        errors.push({ message: `Duplicate id "${provided}"`, line });
+        error(`Duplicate id "${provided}"`, "E_DUP_ID", span);
       }
       seen.add(provided);
       return provided;
@@ -604,32 +675,32 @@ function validate(plan) {
     seen.add(auto);
     return auto;
   };
-  plan.walls.forEach((w, i) => w.id = assign(w.id, w.kind || "wall", i + 1, w.line));
-  plan.rooms.forEach((r, i) => r.id = assign(r.id, "room", i + 1, r.line));
-  plan.doors.forEach((d, i) => d.id = assign(d.id, "door", i + 1, d.line));
-  plan.windows.forEach((w, i) => w.id = assign(w.id, "window", i + 1, w.line));
-  plan.furniture.forEach((f, i) => f.id = assign(f.id, f.kind || "furniture", i + 1, f.line));
-  plan.dims.forEach((d, i) => d.id = assign(d.id, "dim", i + 1, d.line));
+  plan.walls.forEach((w, i) => w.id = assign(w.id, w.kind || "wall", i + 1, w.span));
+  plan.rooms.forEach((r, i) => r.id = assign(r.id, "room", i + 1, r.span));
+  plan.doors.forEach((d, i) => d.id = assign(d.id, "door", i + 1, d.span));
+  plan.windows.forEach((w, i) => w.id = assign(w.id, "window", i + 1, w.span));
+  plan.furniture.forEach((f, i) => f.id = assign(f.id, f.kind || "furniture", i + 1, f.span));
+  plan.dims.forEach((d, i) => d.id = assign(d.id, "dim", i + 1, d.span));
   for (const r of plan.rooms) {
     if (r.size.w <= 0 || r.size.h <= 0)
-      errors.push({ message: `Room "${r.id}" must have a positive size`, line: r.line });
+      error(`Room "${r.id}" must have a positive size`, "E_ROOM_SIZE", r.span);
   }
   for (const f of plan.furniture) {
     if (f.size.w <= 0 || f.size.h <= 0)
-      errors.push({ message: `Furniture "${f.id}" must have a positive size`, line: f.line });
+      error(`Furniture "${f.id}" must have a positive size`, "E_FURN_SIZE", f.span);
   }
   for (const d of plan.doors) {
-    if (d.width <= 0) errors.push({ message: `Door "${d.id}" must have a positive width`, line: d.line });
+    if (d.width <= 0) error(`Door "${d.id}" must have a positive width`, "E_DOOR_WIDTH", d.span);
   }
   for (const w of plan.windows) {
-    if (w.width <= 0) errors.push({ message: `Window "${w.id}" must have a positive width`, line: w.line });
+    if (w.width <= 0) error(`Window "${w.id}" must have a positive width`, "E_WINDOW_WIDTH", w.span);
   }
   for (const w of plan.walls) {
     if (w.thickness <= 0)
-      errors.push({ message: `Wall "${w.id}" must have a positive thickness`, line: w.line });
+      error(`Wall "${w.id}" must have a positive thickness`, "E_WALL_THICKNESS", w.span);
   }
   if (plan.walls.length === 0 && plan.rooms.length === 0 && plan.furniture.length === 0) {
-    warnings.push({ message: "Plan has no walls, rooms, or furniture \u2014 nothing to draw" });
+    warn("Plan has no walls, rooms, or furniture \u2014 nothing to draw", "W_EMPTY_PLAN");
   }
   const onSomeWall = (at, wallRef) => {
     const candidates = wallRef ? plan.walls.filter((w) => w.id === wallRef || w.kind === wallRef) : plan.walls;
@@ -646,11 +717,11 @@ function validate(plan) {
   };
   for (const d of plan.doors) {
     if (plan.walls.length > 0 && !onSomeWall(d.at, d.wall))
-      warnings.push({ message: `Door "${d.id}" does not lie on any wall`, line: d.line });
+      warn(`Door "${d.id}" does not lie on any wall`, "W_DOOR_OFF_WALL", d.span);
   }
   for (const w of plan.windows) {
     if (plan.walls.length > 0 && !onSomeWall(w.at, w.wall))
-      warnings.push({ message: `Window "${w.id}" does not lie on any wall`, line: w.line });
+      warn(`Window "${w.id}" does not lie on any wall`, "W_WINDOW_OFF_WALL", w.span);
   }
   for (let a = 0; a < plan.rooms.length; a++) {
     for (let b = a + 1; b < plan.rooms.length; b++) {
@@ -659,11 +730,11 @@ function validate(plan) {
       const ox = Math.max(0, Math.min(r1.at.x + r1.size.w, r2.at.x + r2.size.w) - Math.max(r1.at.x, r2.at.x));
       const oy = Math.max(0, Math.min(r1.at.y + r1.size.h, r2.at.y + r2.size.h) - Math.max(r1.at.y, r2.at.y));
       if (ox > 1 && oy > 1) {
-        warnings.push({ message: `Rooms "${r1.id}" and "${r2.id}" overlap`, line: r2.line });
+        warn(`Rooms "${r1.id}" and "${r2.id}" overlap`, "W_ROOM_OVERLAP", r2.span);
       }
     }
   }
-  return { errors, warnings };
+  return diags;
 }
 
 // src/render.ts
@@ -955,6 +1026,60 @@ function titleBlock(plan, b, margin, refDim, thin) {
   return `<g>${parts.join("")}</g>`;
 }
 
+// src/diagnostics.ts
+function offsetToLineCol(source, offset) {
+  const o = Math.max(0, Math.min(offset, source.length));
+  let line = 1;
+  let col = 1;
+  for (let k = 0; k < o; k++) {
+    if (source[k] === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+  }
+  return { line, col };
+}
+function lineStart(source, offset) {
+  let k = Math.max(0, Math.min(offset, source.length));
+  while (k > 0 && source[k - 1] !== "\n") k--;
+  return k;
+}
+function lineEnd(source, offset) {
+  let k = Math.max(0, Math.min(offset, source.length));
+  while (k < source.length && source[k] !== "\n") k++;
+  return k;
+}
+function formatDiagnostic(source, d) {
+  const codeTag = d.code ? `[${d.code}]` : "";
+  const header = `${d.severity}${codeTag}: ${d.message}`;
+  const lines = [header];
+  if (d.span) {
+    const { line, col } = offsetToLineCol(source, d.span.start);
+    const ls = lineStart(source, d.span.start);
+    const le = lineEnd(source, d.span.start);
+    const srcLine = source.slice(ls, le);
+    const caretStart = d.span.start - ls;
+    const caretEnd = Math.min(d.span.end, le) - ls;
+    const caretLen = Math.max(1, caretEnd - caretStart);
+    const gutter = String(line);
+    const pad = " ".repeat(gutter.length);
+    lines.push(`${pad} --> ${line}:${col}`);
+    lines.push(`${pad} |`);
+    lines.push(`${gutter} | ${srcLine}`);
+    lines.push(`${pad} | ${" ".repeat(caretStart)}${"^".repeat(caretLen)}`);
+    for (const hint of d.hints ?? []) {
+      lines.push(`${pad} = help: ${hint}`);
+    }
+  } else {
+    for (const hint of d.hints ?? []) {
+      lines.push(`  = help: ${hint}`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/index.ts
 var cache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 64;
@@ -974,24 +1099,28 @@ function compile(source, opts = {}) {
   }
   return result;
 }
+function toLegacy(source, d) {
+  if (!d.span) return { message: d.message };
+  const { line, col } = offsetToLineCol(source, d.span.start);
+  return { message: d.message, line, col };
+}
 function compileUncached(source, opts) {
-  const { plan, errors: parseErrors } = parse(source);
-  if (!plan || parseErrors.length > 0) {
-    return { svg: "", errors: parseErrors, warnings: [] };
-  }
-  const { errors, warnings } = validate(plan);
-  if (errors.length > 0) {
-    return { svg: "", errors, warnings, ast: plan };
-  }
-  const svg = render(plan, opts);
-  return { svg, errors: [], warnings, ast: plan };
+  const { plan, diagnostics: parseDiags } = parse(source);
+  const diagnostics = plan ? [...parseDiags, ...validate(plan)] : [...parseDiags];
+  const errs = diagnostics.filter((d) => d.severity === "error");
+  const errors = errs.map((d) => toLegacy(source, d));
+  const warnings = diagnostics.filter((d) => d.severity === "warning").map((d) => toLegacy(source, d));
+  const svg = plan && errs.length === 0 ? render(plan, opts) : "";
+  return { svg, errors, warnings, diagnostics, ast: plan };
 }
 function clearCache() {
   cache.clear();
 }
 
 export {
+  offsetToLineCol,
+  formatDiagnostic,
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-J5DEA2KQ.js.map
+//# sourceMappingURL=chunk-ICYNEDSM.js.map