@chanmeng666/archlang 0.4.0 → 0.5.0

package/dist/{chunk-DHNWMOP7.js → chunk-GUNWYUR2.js}

@@ -301,6 +301,58 @@ function levenshtein(a, b) {
   return dp[m];
 }
 
+// src/theme.ts
+var DEFAULT_THEME = {
+  bg: "#ffffff",
+  pocheBase: "#e9e4db",
+  pocheHatch: "#b9b1a4",
+  wallStroke: "#1b1b1b",
+  roomFill: "#fbfaf7",
+  roomLabel: "#222222",
+  areaLabel: "#7a7a7a",
+  furnitureStroke: "#a8a29a",
+  furnitureFill: "#f4f2ee",
+  furnitureLabel: "#9a948c",
+  opening: "#ffffff",
+  doorLeaf: "#555555",
+  windowPane: "#3a6ea5",
+  dim: "#0E5484",
+  annotation: "#333333",
+  annotationMuted: "#888888",
+  column: "#4a4a4a",
+  lineWeight: 1,
+  font: "Helvetica, Arial, sans-serif"
+};
+var ALIASES = {
+  background: "bg",
+  wall: "wallStroke",
+  wallFill: "pocheBase",
+  wallHatch: "pocheHatch",
+  room: "roomFill",
+  furniture: "furnitureFill",
+  door: "doorLeaf",
+  window: "windowPane"
+};
+function resolveThemeKey(key) {
+  if (key in DEFAULT_THEME) return key;
+  if (key in ALIASES) return ALIASES[key];
+  return null;
+}
+function isNumericThemeKey(key) {
+  return key === "lineWeight";
+}
+function mergeTheme(...layers) {
+  const out = { ...DEFAULT_THEME };
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const k of Object.keys(layer)) {
+      const v = layer[k];
+      if (v !== void 0) out[k] = v;
+    }
+  }
+  return out;
+}
+
 // src/geometry.ts
 var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
@@ -392,6 +444,46 @@ function isOnSomeWall(walls, at, ref) {
   return false;
 }
 
+// src/hatches.ts
+var KNOWN_MATERIALS = ["poche", "concrete", "brick", "insulation", "tile", "none"];
+var DEFAULT_MATERIAL = "poche";
+function patternId(material) {
+  return material === "poche" ? "poche" : `hatch-${material}`;
+}
+var HATCHES = {
+  poche: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" patternTransform="rotate(45)"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/><line x1="0" y1="0" x2="0" y2="${c.fmt(c.gap)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.7)}"/></pattern>`,
+  // Aggregate speckle.
+  concrete: (id, c) => {
+    const w = c.gap * 1.6;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><circle cx="${c.fmt(w * 0.25)}" cy="${c.fmt(w * 0.3)}" r="${c.fmt(c.thin * 0.9)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.7)}" cy="${c.fmt(w * 0.62)}" r="${c.fmt(c.thin * 0.6)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.45)}" cy="${c.fmt(w * 0.85)}" r="${c.fmt(c.thin * 0.75)}" fill="${c.line}"/></pattern>`;
+  },
+  // Running-bond brick courses.
+  brick: (id, c) => {
+    const w = c.gap * 3;
+    const h = c.gap * 1.4;
+    const sw = c.fmt(c.thin * 0.6);
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(h)}"><rect width="${c.fmt(w)}" height="${c.fmt(h)}" fill="${c.base}"/><line x1="0" y1="${c.fmt(h)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w / 2)}" y1="0" x2="${c.fmt(w / 2)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="0" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w)}" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/></pattern>`;
+  },
+  // Cross-hatch batting.
+  insulation: (id, c) => {
+    const w = c.gap * 1.2;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><path d="M0,0 L${c.fmt(w)},${c.fmt(w)} M${c.fmt(w)},0 L0,${c.fmt(w)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.5)}" fill="none"/></pattern>`;
+  },
+  // Square tile grid.
+  tile: (id, c) => {
+    const w = c.gap * 1.8;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><rect x="0" y="0" width="${c.fmt(w)}" height="${c.fmt(w)}" fill="none" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.6)}"/></pattern>`;
+  },
+  // Solid fill, no hatch.
+  none: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/></pattern>`
+};
+function isKnownMaterial(name) {
+  return KNOWN_MATERIALS.includes(name);
+}
+function hatchPattern(material, c) {
+  return HATCHES[material](patternId(material), c);
+}
+
 // src/elements/wall.ts
 var wall = {
   kind: "wall",
@@ -402,6 +494,11 @@ var wall = {
     const category = ctx.eatIdent().value;
     ctx.eatKeyword("thickness");
     const thickness = ctx.parseExpr();
+    let material;
+    if (ctx.isKeyword("material")) {
+      ctx.next();
+      material = ctx.eatIdent().value;
+    }
     ctx.eat("lcurly");
     const points = [];
     let closed = false;
@@ -419,7 +516,7 @@ var wall = {
     }
     ctx.eat("rcurly");
     if (points.length < 2) ctx.fail("A wall needs at least two points", kw);
-    return { kind: "wall", id, category, thickness, points, closed, line: kw.line };
+    return { kind: "wall", id, category, thickness, material, points, closed, line: kw.line };
   },
   idPrefix: (node) => node.category || "wall",
   resolve(node, ctx) {
@@ -431,7 +528,18 @@ var wall = {
     if (thickness <= 0) {
       ctx.diag({ severity: "error", message: `Wall "${id}" must have a positive thickness`, code: "E_WALL_THICKNESS", span: n.span });
     }
-    return { kind: "wall", id, category: n.category, thickness, points, closed: n.closed, span: n.span };
+    let material = DEFAULT_MATERIAL;
+    if (n.material !== void 0) {
+      if (isKnownMaterial(n.material)) material = n.material;
+      else
+        ctx.diag({
+          severity: "warning",
+          message: `Unknown wall material "${n.material}" (known: ${KNOWN_MATERIALS.join(", ")}); using the default hatch`,
+          code: "W_UNKNOWN_MATERIAL",
+          span: n.span
+        });
+    }
+    return { kind: "wall", id, category: n.category, thickness, material, points, closed: n.closed, span: n.span };
   },
   bounds(resolved) {
     const w = resolved;
@@ -873,7 +981,7 @@ register(dim);
 register(column);
 
 // src/parser.ts
-var SETTINGS = ["units", "grid", "scale", "north", "title", "let", "component"];
+var SETTINGS = ["units", "grid", "scale", "north", "title", "theme", "let", "component"];
 var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
 var ParseError = class extends Error {
   constructor(message, span) {
@@ -1036,6 +1144,10 @@ var Parser = class {
             plan.title = n;
             break;
           }
+          case "theme": {
+            plan.theme = { ...plan.theme, ...this.parseTheme() };
+            break;
+          }
           case "let": {
             const n = this.parseLet();
             n.span = this.spanFrom(start);
@@ -1145,6 +1257,35 @@ var Parser = class {
     this.eat("rcurly");
     return node;
   }
+  /** `theme { key: <value> … }` — colours (strings), `lineWeight` (number), `font` (string). */
+  parseTheme() {
+    this.eatKeyword("theme");
+    this.eat("lcurly");
+    const t = {};
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const keyTok = this.eatIdent();
+      if (this.isType("colon")) this.next();
+      const resolved = resolveThemeKey(keyTok.value);
+      if (!resolved) {
+        this.diagnostics.push({
+          severity: "warning",
+          message: `Unknown theme key "${keyTok.value}"`,
+          code: "W_UNKNOWN_THEME_KEY",
+          span: { start: keyTok.start, end: keyTok.end }
+        });
+        if (this.isType("string") || this.isType("number")) this.next();
+        else this.fail(`Expected a value for theme key "${keyTok.value}"`);
+        continue;
+      }
+      if (isNumericThemeKey(resolved)) {
+        t[resolved] = this.eatNumber();
+      } else {
+        t[resolved] = this.eatString();
+      }
+    }
+    this.eat("rcurly");
+    return t;
+  }
   parseLet() {
     const kw = this.eatKeyword("let");
     const name = this.eatIdent().value;
@@ -1343,6 +1484,7 @@ function resolve(ast) {
     scale: ast.scale,
     north: ast.north,
     title: ast.title,
+    theme: ast.theme,
     elements,
     walls
   };
@@ -1362,26 +1504,104 @@ var RENDER_PASSES = [
   "annotations"
 ];
 
+// src/geometry/union.ts
+function uniqSorted(values) {
+  const out = [...new Set(values)].sort((a, b) => a - b);
+  return out;
+}
+function rectUnionOutline(rects) {
+  if (rects.length === 0) return [];
+  const xs = uniqSorted(rects.flatMap((r) => [r.x0, r.x1]));
+  const ys = uniqSorted(rects.flatMap((r) => [r.y0, r.y1]));
+  const nx = xs.length - 1;
+  const ny = ys.length - 1;
+  const filled = (i, j) => {
+    if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+    const cx = (xs[i] + xs[i + 1]) / 2;
+    const cy = (ys[j] + ys[j + 1]) / 2;
+    return rects.some((r) => cx > r.x0 && cx < r.x1 && cy > r.y0 && cy < r.y1);
+  };
+  const key = (x, y) => `${x},${y}`;
+  const starts = /* @__PURE__ */ new Map();
+  const pushEdge = (ax, ay, bx, by) => {
+    const k = key(ax, ay);
+    const list = starts.get(k);
+    if (list) list.push({ x: bx, y: by });
+    else starts.set(k, [{ x: bx, y: by }]);
+  };
+  for (let i = 0; i < nx; i++) {
+    for (let j = 0; j < ny; j++) {
+      if (!filled(i, j)) continue;
+      const x0 = xs[i];
+      const x1 = xs[i + 1];
+      const y0 = ys[j];
+      const y1 = ys[j + 1];
+      if (!filled(i, j - 1)) pushEdge(x1, y0, x0, y0);
+      if (!filled(i - 1, j)) pushEdge(x0, y0, x0, y1);
+      if (!filled(i, j + 1)) pushEdge(x0, y1, x1, y1);
+      if (!filled(i + 1, j)) pushEdge(x1, y1, x1, y0);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const edgeKey = (a, b) => `${a.x},${a.y}->${b.x},${b.y}`;
+  const loops = [];
+  const takeNext = (from, prevDir) => {
+    const list = starts.get(key(from.x, from.y));
+    if (!list) return null;
+    const candidates = list.filter((to) => !used.has(edgeKey(from, to)));
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1 || !prevDir) return candidates[0];
+    let best = candidates[0];
+    let bestScore = -Infinity;
+    for (const c of candidates) {
+      const dir = { x: c.x - from.x, y: c.y - from.y };
+      const cross = prevDir.x * dir.y - prevDir.y * dir.x;
+      if (cross > bestScore) {
+        bestScore = cross;
+        best = c;
+      }
+    }
+    return best;
+  };
+  for (const [startKey, ends] of starts) {
+    for (const firstEnd of ends) {
+      const [sx, sy] = startKey.split(",").map(Number);
+      const start = { x: sx, y: sy };
+      if (used.has(edgeKey(start, firstEnd))) continue;
+      const loop = [start];
+      let cur = start;
+      let next = firstEnd;
+      let dir = null;
+      while (next) {
+        used.add(edgeKey(cur, next));
+        if (next.x === start.x && next.y === start.y) break;
+        loop.push(next);
+        dir = { x: next.x - cur.x, y: next.y - cur.y };
+        cur = next;
+        next = takeNext(cur, dir);
+      }
+      if (loop.length >= 4) loops.push(mergeCollinear(loop));
+    }
+  }
+  return loops;
+}
+function mergeCollinear(loop) {
+  const n = loop.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const prev = loop[(i - 1 + n) % n];
+    const cur = loop[i];
+    const next = loop[(i + 1) % n];
+    const d1x = cur.x - prev.x;
+    const d1y = cur.y - prev.y;
+    const d2x = next.x - cur.x;
+    const d2y = next.y - cur.y;
+    if (d1x * d2y - d1y * d2x !== 0) out.push(cur);
+  }
+  return out.length >= 3 ? out : loop;
+}
+
 // src/render.ts
-var THEME = {
-  bg: "#ffffff",
-  pocheBase: "#e9e4db",
-  pocheHatch: "#b9b1a4",
-  wallStroke: "#1b1b1b",
-  roomFill: "#fbfaf7",
-  roomLabel: "#222222",
-  areaLabel: "#7a7a7a",
-  furnitureStroke: "#a8a29a",
-  furnitureFill: "#f4f2ee",
-  furnitureLabel: "#9a948c",
-  opening: "#ffffff",
-  doorLeaf: "#555555",
-  windowPane: "#3a6ea5",
-  dim: "#0E5484",
-  annotation: "#333333",
-  annotationMuted: "#888888",
-  column: "#4a4a4a"
-};
 function fmt(v) {
   const r = Math.round(v * 100) / 100;
   return Object.is(r, -0) ? "0" : String(r);
@@ -1408,15 +1628,56 @@ function planBounds(ir) {
   }
   return b;
 }
+function allOrthogonal(walls) {
+  return walls.every((w) => segmentsOfWall(w).every((s) => s.a.x === s.b.x || s.a.y === s.b.y));
+}
+function loopsToPath(loops) {
+  return loops.map((loop) => "M " + loop.map(pt).join(" L ") + " Z").join(" ");
+}
+function materialsUsed(walls) {
+  return [...new Set(walls.map((w) => w.material))].sort();
+}
+function renderWalls(walls, ctx) {
+  if (walls.length === 0) return [];
+  const ops = [];
+  for (const mat of materialsUsed(walls)) {
+    const group = walls.filter((w) => w.material === mat);
+    if (!allOrthogonal(group)) {
+      const def = registry.get("wall");
+      ops.push(...group.flatMap((w) => def.render(w, ctx)));
+      continue;
+    }
+    const rects = [];
+    for (const w of group) {
+      for (const s of segmentsOfWall(w)) {
+        const corners = segmentRectangle(s.a, s.b, s.thickness);
+        const xsv = corners.map((c) => c.x);
+        const ysv = corners.map((c) => c.y);
+        rects.push({ x0: Math.min(...xsv), y0: Math.min(...ysv), x1: Math.max(...xsv), y1: Math.max(...ysv) });
+      }
+    }
+    const loops = rectUnionOutline(rects);
+    if (loops.length === 0) continue;
+    const d = loopsToPath(loops);
+    ops.push({ pass: "wallFill", svg: `<path d="${d}" fill="url(#${patternId(mat)})" fill-rule="nonzero"/>` });
+    ops.push({
+      pass: "wallFace",
+      svg: `<path d="${d}" fill="none" stroke="${ctx.theme.wallStroke}" stroke-width="${ctx.fmt(ctx.sizes.wallStroke)}" stroke-linejoin="miter"/>`
+    });
+  }
+  return ops;
+}
 function render(ir, opts = {}) {
+  const THEME = mergeTheme(DEFAULT_THEME, ir.theme, opts.theme);
+  const lw = THEME.lineWeight;
   const b = planBounds(ir);
   const drawW = b.maxX - b.minX;
   const drawH = b.maxY - b.minY;
   const refDim = Math.max(drawW, drawH, 1);
   const sizes = {
     refDim,
-    wallStroke: refDim * 28e-4,
-    thin: refDim * 16e-4,
+    wallStroke: refDim * 28e-4 * lw,
+    thin: refDim * 16e-4 * lw,
     roomFont: refDim * 0.03,
     areaFont: refDim * 0.022,
     dimFont: refDim * 0.02,
@@ -1432,28 +1693,30 @@ function render(ir, opts = {}) {
   const out = [];
   const svgAttrs = opts.width ? `width="${fmt(opts.width)}" height="${fmt(opts.width * vbH / vbW)}"` : "";
   out.push(
-    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="Helvetica, Arial, sans-serif">`
-  );
-  out.push(
-    `<defs><pattern id="poche" patternUnits="userSpaceOnUse" width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" patternTransform="rotate(45)"><rect width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" fill="${THEME.pocheBase}"/><line x1="0" y1="0" x2="0" y2="${fmt(hatchGap)}" stroke="${THEME.pocheHatch}" stroke-width="${fmt(thin * 0.7)}"/></pattern></defs>`
+    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="${xml(THEME.font)}">`
   );
+  const hatchCtx = { fmt, gap: hatchGap, thin, base: THEME.pocheBase, line: THEME.pocheHatch };
+  const patterns = materialsUsed(ir.walls).map((m) => hatchPattern(m, hatchCtx)).join("");
+  out.push(`<defs>${patterns}</defs>`);
   out.push(`<rect x="${fmt(vbX)}" y="${fmt(vbY)}" width="${fmt(vbW)}" height="${fmt(vbH)}" fill="${THEME.bg}"/>`);
   const ctx = { fmt, pt, xml, theme: THEME, sizes, bounds: b };
   const ops = ir.elements.flatMap((el) => {
+    if (el.kind === "wall") return [];
     const def = registry.get(el.kind);
     return def ? def.render(el, ctx) : [];
   });
+  ops.push(...renderWalls(ir.walls, ctx));
   for (const pass of RENDER_PASSES) {
     for (const op of ops) if (op.pass === pass) out.push(op.svg);
   }
-  out.push(northArrow(ir, b, margin, refDim));
-  out.push(scaleBar(b, margin, refDim, thin));
-  const tb = titleBlock(ir, b, margin, refDim, thin);
+  out.push(northArrow(ir, b, margin, refDim, THEME));
+  out.push(scaleBar(b, margin, refDim, thin, THEME));
+  const tb = titleBlock(ir, b, margin, refDim, thin, THEME);
   if (tb) out.push(tb);
   out.push("</svg>");
   return out.join("\n");
 }
-function northArrow(ir, b, margin, refDim) {
+function northArrow(ir, b, margin, refDim, THEME) {
   const r = refDim * 0.045;
   const cx = b.maxX - r;
   const cy = b.minY - margin * 0.55;
@@ -1483,7 +1746,7 @@ function northArrow(ir, b, margin, refDim) {
   const ly = cy + ny * (r + fs * 0.8);
   return `<g><polygon points="${tri}" fill="${THEME.annotation}" transform="rotate(${fmt(deg)} ${fmt(cx)} ${fmt(cy)})"/><text x="${fmt(lx)}" y="${fmt(ly)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="middle" dominant-baseline="central">N</text></g>`;
 }
-function scaleBar(b, margin, refDim, thin) {
+function scaleBar(b, margin, refDim, thin, THEME) {
   const barLen = niceBarLength(refDim * 0.3);
   const x0 = b.minX;
   const y0 = b.maxY + margin * 0.55;
@@ -1503,7 +1766,7 @@ function scaleBar(b, margin, refDim, thin) {
   );
   return `<g>${parts.join("")}</g>`;
 }
-function titleBlock(ir, b, margin, refDim, thin) {
+function titleBlock(ir, b, margin, refDim, thin, THEME) {
   const t = ir.title;
   if (!t && !ir.scale) return null;
   const boxW = refDim * 0.34;
@@ -1596,7 +1859,7 @@ function formatDiagnostic(source, d) {
 var cache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 64;
 function compile(source, opts = {}) {
-  const key = JSON.stringify([source, opts.width ?? null]);
+  const key = JSON.stringify([source, opts.width ?? null, opts.theme ?? null]);
   if (!opts.noCache) {
     const hit = cache.get(key);
     if (hit) return hit;
@@ -1636,4 +1899,4 @@ export {
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-DHNWMOP7.js.map
+//# sourceMappingURL=chunk-GUNWYUR2.js.map