@miragon/wardley-dsl 0.0.0

package/dist/index.cjs

@@ -0,0 +1,593 @@
+'use strict';
+
+var wardleySchemaModel = require('@miragon/wardley-schema-model');
+
+// src/parser.ts
+
+// src/lexer.ts
+var COORDS_RE = /\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/;
+function parseCoords(line) {
+  const m = COORDS_RE.exec(line);
+  if (!m) return null;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (Number.isNaN(a) || Number.isNaN(b)) return null;
+  return { a, b };
+}
+function stripCoords(line) {
+  return line.replace(COORDS_RE, " ");
+}
+var PAREN_RE = /\(([^)]*)\)/g;
+var METHODS = /* @__PURE__ */ new Set(["build", "buy", "outsource"]);
+function parseDecorators(line) {
+  const dec = {};
+  let rest = line;
+  rest = rest.replace(PAREN_RE, (_full, group) => {
+    for (const rawToken of group.split(",")) {
+      const token = rawToken.trim().toLowerCase();
+      if (token === "market") dec.market = true;
+      else if (token === "ecosystem") dec.ecosystem = true;
+      else if (token === "inertia") dec.inertia = true;
+      else if (METHODS.has(token)) dec.method = token;
+    }
+    return " ";
+  });
+  rest = rest.replace(/\binertia\b/i, () => {
+    dec.inertia = true;
+    return " ";
+  });
+  return { decorators: dec, rest };
+}
+var COLOR_RE = /\(\s*color\s+(#[0-9a-fA-F]{3,8}|[a-zA-Z][\w-]*)\s*\)/i;
+function parseColor(line) {
+  const m = COLOR_RE.exec(line);
+  if (!m || !m[1]) return { rest: line };
+  return { color: m[1], rest: line.replace(COLOR_RE, " ") };
+}
+var LABEL_OFFSET_RE = /\blabel\s*\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/i;
+function parseLabelOffset(line) {
+  const m = LABEL_OFFSET_RE.exec(line);
+  if (!m) return { labelOffset: null, rest: line };
+  const dx = Number(m[1]);
+  const dy = Number(m[2]);
+  const rest = line.replace(LABEL_OFFSET_RE, " ");
+  if (Number.isNaN(dx) || Number.isNaN(dy)) return { labelOffset: null, rest };
+  return { labelOffset: { dx, dy }, rest };
+}
+function keywordOf(line) {
+  const m = /^\s*([A-Za-z][\w-]*)/.exec(line);
+  return m ? m[1].toLowerCase() : "";
+}
+function slug(label) {
+  return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "x";
+}
+
+// src/parser.ts
+var DEP_RE = /^(.+?)\s*->\s*(.+)$/;
+var FLOW_RE = /^(.+?)\s*\+(?:'([^']*)')?(<>|>|<)\s*(.+)$/;
+var NON_LINK_KEYWORDS = /* @__PURE__ */ new Set([
+  "title",
+  "style",
+  "size",
+  "evolution",
+  "y-axis",
+  "annotations",
+  "annotation",
+  "evolve"
+]);
+var KNOWN_STYLES = /* @__PURE__ */ new Set(["wardley", "handwritten", "colour", "dark"]);
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
+  return out;
+}
+var IdAllocator = class {
+  used = /* @__PURE__ */ new Set();
+  alloc(prefix, label) {
+    const base = `${prefix}_${slug(label)}`;
+    let id = base;
+    let i = 2;
+    while (this.used.has(id)) id = `${base}_${i++}`;
+    this.used.add(id);
+    return id;
+  }
+};
+function parseDSL(text) {
+  const ids = new IdAllocator();
+  const nameToId = /* @__PURE__ */ new Map();
+  const elements = [];
+  const rawPassthrough = [];
+  const pendingLinks = [];
+  const pendingEvolve = [];
+  const pendingPipeline = [];
+  let config = { title: "Untitled Map" };
+  let annoCounter = 0;
+  const register = (name, id) => {
+    if (!nameToId.has(name)) nameToId.set(name, id);
+  };
+  const pushLink = (line, raw) => {
+    const semi = line.indexOf(";");
+    const core = semi >= 0 ? line.slice(0, semi).trim() : line;
+    const linkLabel = semi >= 0 ? line.slice(semi + 1).trim() : "";
+    const dep = DEP_RE.exec(core);
+    const flow = dep ? null : FLOW_RE.exec(core);
+    if (dep) {
+      pendingLinks.push({
+        left: dep[1].trim(),
+        right: dep[2].trim(),
+        kind: "dependency",
+        ...linkLabel ? { label: linkLabel } : {},
+        raw
+      });
+      return true;
+    }
+    if (flow) {
+      const op = flow[3];
+      pendingLinks.push({
+        left: flow[1].trim(),
+        right: flow[4].trim(),
+        kind: "flow",
+        bidirectional: op === "<>",
+        reverse: op === "<",
+        ...flow[2] ? { flowValue: flow[2] } : {},
+        ...linkLabel ? { label: linkLabel } : {},
+        raw
+      });
+      return true;
+    }
+    return false;
+  };
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    const kw = keywordOf(line);
+    const after = line.slice(kw.length).trim();
+    if (!NON_LINK_KEYWORDS.has(kw) && !parseCoords(line) && pushLink(line, raw)) {
+      continue;
+    }
+    switch (kw) {
+      case "title":
+        config = { ...config, title: after };
+        break;
+      case "anchor": {
+        const node = parseNode(after);
+        if (!node) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const id = ids.alloc("anchor", node.name);
+        const anchor = compact({
+          id,
+          elementType: "anchor",
+          label: node.name,
+          position: { visibility: node.coords.a, evolution: node.coords.b },
+          labelOffset: node.labelOffset
+        });
+        elements.push(anchor);
+        register(node.name, id);
+        break;
+      }
+      case "component":
+      case "market":
+      case "ecosystem": {
+        const node = parseNode(after);
+        if (!node) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const decorators = mergeLegacy(kw, node.decorators);
+        const id = ids.alloc("cmp", node.name);
+        const component = compact({
+          id,
+          elementType: "component",
+          label: node.name,
+          position: { visibility: node.coords.a, evolution: node.coords.b },
+          labelOffset: node.labelOffset,
+          decorators: Object.keys(decorators).length ? decorators : void 0
+        });
+        elements.push(component);
+        register(node.name, id);
+        break;
+      }
+      case "note": {
+        const { color, rest } = parseColor(after);
+        const coords = parseCoords(rest);
+        const textPart = stripCoords(rest).trim().replace(/\\n/g, "\n");
+        if (!coords) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const id = ids.alloc("note", textPart || "note");
+        const note = compact({
+          id,
+          elementType: "note",
+          label: textPart,
+          position: { visibility: coords.a, evolution: coords.b },
+          color
+        });
+        elements.push(note);
+        break;
+      }
+      case "pipeline": {
+        const coords = parseCoords(after);
+        const name = stripCoords(after).trim();
+        if (!coords || !name) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        pendingPipeline.push({ name, start: coords.a, end: coords.b, raw });
+        break;
+      }
+      case "evolve": {
+        const ev = parseEvolve(after);
+        if (!ev) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        pendingEvolve.push({ ...ev, raw });
+        break;
+      }
+      case "style": {
+        const s = after.toLowerCase();
+        if (KNOWN_STYLES.has(s)) config = { ...config, style: s };
+        else rawPassthrough.push(raw);
+        break;
+      }
+      case "size": {
+        const coords = parseCoords(after);
+        if (coords) config = { ...config, size: { width: coords.a, height: coords.b } };
+        else rawPassthrough.push(raw);
+        break;
+      }
+      case "evolution": {
+        const parts = after.split("->").map((s) => s.trim());
+        if (parts.length === 4) {
+          config = { ...config, evolutionLabels: [parts[0], parts[1], parts[2], parts[3]] };
+        } else rawPassthrough.push(raw);
+        break;
+      }
+      case "y-axis": {
+        const parts = after.split("->").map((s) => s.trim()).filter(Boolean);
+        if (parts.length) config = { ...config, yAxisLabel: parts[0] };
+        else rawPassthrough.push(raw);
+        break;
+      }
+      case "annotations": {
+        const coords = parseCoords(after);
+        if (coords) {
+          config = {
+            ...config,
+            annotationsBoxPosition: { visibility: coords.a, evolution: coords.b }
+          };
+        } else rawPassthrough.push(raw);
+        break;
+      }
+      case "annotation": {
+        const coords = parseCoords(after);
+        if (!coords) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const numMatch = /^\s*(\d+)/.exec(after);
+        const number = numMatch ? Number(numMatch[1]) : ++annoCounter;
+        const text2 = stripCoords(after.replace(/^\s*\d+\s*/, "")).trim();
+        const position = { visibility: coords.a, evolution: coords.b };
+        const annotation = {
+          id: ids.alloc("anno", String(number)),
+          elementType: "annotation",
+          label: text2,
+          position,
+          number,
+          positions: [position],
+          text: text2
+        };
+        elements.push(annotation);
+        break;
+      }
+      case "pioneers":
+      case "settlers":
+      case "townplanners": {
+        const coords = parseCoords(after);
+        const trailing = stripCoords(after).trim().split(/\s+/).filter(Boolean);
+        const width = Number(trailing[0]);
+        const height = Number(trailing[1]);
+        if (!coords || Number.isNaN(width) || Number.isNaN(height)) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const attitude = {
+          id: ids.alloc("attitude", kw),
+          elementType: "attitude",
+          kind: kw,
+          label: "",
+          position: { visibility: coords.a, evolution: coords.b },
+          width,
+          height
+        };
+        elements.push(attitude);
+        break;
+      }
+      case "accelerator":
+      case "deaccelerator": {
+        const node = parseNode(after);
+        if (!node) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const id = ids.alloc("accel", node.name);
+        const accelerator = {
+          id,
+          elementType: "accelerator",
+          direction: kw === "deaccelerator" ? "deaccelerate" : "accelerate",
+          label: node.name,
+          position: { visibility: node.coords.a, evolution: node.coords.b }
+        };
+        elements.push(accelerator);
+        register(node.name, id);
+        break;
+      }
+      case "submap": {
+        const node = parseNode(after);
+        if (!node) {
+          rawPassthrough.push(raw);
+          break;
+        }
+        const id = ids.alloc("submap", node.name);
+        const submap = {
+          id,
+          elementType: "submap",
+          label: node.name,
+          position: { visibility: node.coords.a, evolution: node.coords.b }
+        };
+        elements.push(submap);
+        register(node.name, id);
+        break;
+      }
+      default: {
+        if (!pushLink(line, raw)) rawPassthrough.push(raw);
+      }
+    }
+  }
+  for (const ev of pendingEvolve) {
+    const id = nameToId.get(ev.name);
+    const idx = elements.findIndex((e) => e.id === id);
+    if (idx < 0 || elements[idx].elementType !== "component") {
+      rawPassthrough.push(ev.raw);
+      continue;
+    }
+    const movement = compact({
+      targetEvolution: ev.target,
+      newLabel: ev.newLabel,
+      method: ev.method
+    });
+    elements[idx] = { ...elements[idx], movement };
+  }
+  for (const p of pendingPipeline) {
+    const refId = nameToId.get(p.name);
+    const ref = elements.find((e) => e.id === refId);
+    const visibility = ref ? ref.position.visibility : 0.5;
+    const id = ids.alloc("pipeline", p.name);
+    const pipeline = {
+      id,
+      elementType: "pipeline",
+      label: p.name,
+      position: { visibility, evolution: (p.start + p.end) / 2 },
+      evolutionStart: p.start,
+      evolutionEnd: p.end,
+      childIds: []
+    };
+    elements.push(pipeline);
+  }
+  let depN = 0;
+  let flowN = 0;
+  const edges = [];
+  for (const link of pendingLinks) {
+    const fromId = nameToId.get(link.left);
+    const toId = nameToId.get(link.right);
+    if (!fromId || !toId) {
+      rawPassthrough.push(link.raw);
+      continue;
+    }
+    if (link.kind === "dependency") {
+      edges.push(
+        compact({
+          id: `dep_${++depN}`,
+          edgeType: "dependency",
+          from: fromId,
+          to: toId,
+          label: link.label
+        })
+      );
+    } else {
+      const [f, t] = link.reverse ? [toId, fromId] : [fromId, toId];
+      edges.push(
+        compact({
+          id: `flow_${++flowN}`,
+          edgeType: "flow",
+          from: f,
+          to: t,
+          bidirectional: link.bidirectional ? true : void 0,
+          flowValue: link.flowValue,
+          label: link.label
+        })
+      );
+    }
+  }
+  const map = compact({
+    schemaVersion: wardleySchemaModel.CURRENT_SCHEMA_VERSION,
+    config,
+    elements,
+    edges,
+    rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
+  });
+  return wardleySchemaModel.validateMap(map);
+}
+function parseNode(after) {
+  const lo = parseLabelOffset(after);
+  const dec = parseDecorators(lo.rest);
+  const coords = parseCoords(dec.rest);
+  if (!coords) return null;
+  const name = stripCoords(dec.rest).trim();
+  if (!name) return null;
+  return compact({
+    name,
+    coords,
+    decorators: dec.decorators,
+    labelOffset: lo.labelOffset ?? void 0
+  });
+}
+function mergeLegacy(kw, dec) {
+  const merged = { ...dec };
+  if (kw === "market") merged["market"] = true;
+  if (kw === "ecosystem") merged["ecosystem"] = true;
+  return compact(merged);
+}
+function parseEvolve(after) {
+  const dec = parseDecorators(after);
+  const tokens = dec.rest.trim().split(/\s+/);
+  if (tokens.length < 2) return null;
+  const last = tokens[tokens.length - 1];
+  const target = Number(last);
+  if (Number.isNaN(target)) return null;
+  const namePart = tokens.slice(0, -1).join(" ").trim();
+  if (!namePart) return null;
+  const renameIdx = namePart.indexOf("->");
+  const name = renameIdx >= 0 ? namePart.slice(0, renameIdx).trim() : namePart;
+  const newLabel = renameIdx >= 0 ? namePart.slice(renameIdx + 2).trim() : void 0;
+  return compact({
+    name,
+    newLabel: newLabel || void 0,
+    target,
+    method: dec.decorators.method
+  });
+}
+
+// src/serializer.ts
+function r(n) {
+  return String(Math.round(n * 1e3) / 1e3);
+}
+var NAMED_TYPES = /* @__PURE__ */ new Set(["anchor", "component", "accelerator", "submap"]);
+function defaultName(type) {
+  return type === "anchor" ? "User" : type === "accelerator" ? "Accelerator" : type === "submap" ? "Submap" : "Component";
+}
+function uniqueNames(map) {
+  const used = /* @__PURE__ */ new Set();
+  const byId = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    if (!NAMED_TYPES.has(el.elementType)) continue;
+    const base = el.label.trim().replace(/->/g, "\u2192") || defaultName(el.elementType);
+    let name = base;
+    let i = 2;
+    while (used.has(name)) name = `${base} ${i++}`;
+    used.add(name);
+    byId.set(el.id, name);
+  }
+  return byId;
+}
+function offsetSuffix(lo) {
+  return lo ? ` label [${r(lo.dx)}, ${r(lo.dy)}]` : "";
+}
+function decoratorSuffix(dec) {
+  if (!dec) return "";
+  const paren = [];
+  if (dec.market) paren.push("market");
+  if (dec.ecosystem) paren.push("ecosystem");
+  if (dec.method) paren.push(dec.method);
+  let out = "";
+  if (paren.length) out += ` (${paren.join(", ")})`;
+  if (dec.inertia) out += " inertia";
+  return out;
+}
+function serializeDSL(map) {
+  const lines = [];
+  const names = uniqueNames(map);
+  const nameOf = (el) => names.get(el.id) ?? el.label;
+  lines.push(`title ${map.config.title}`);
+  if (map.config.style) lines.push(`style ${map.config.style}`);
+  if (map.config.size)
+    lines.push(`size [${r(map.config.size.width)}, ${r(map.config.size.height)}]`);
+  if (map.config.evolutionLabels) lines.push(`evolution ${map.config.evolutionLabels.join("->")}`);
+  if (map.config.yAxisLabel) lines.push(`y-axis ${map.config.yAxisLabel}`);
+  if (map.config.annotationsBoxPosition) {
+    const b = map.config.annotationsBoxPosition;
+    lines.push(`annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
+  }
+  const evolveLines = [];
+  for (const el of map.elements) {
+    lines.push(elementLine(el, nameOf(el)));
+    if (el.elementType === "component" && el.movement) {
+      evolveLines.push(evolveLine(el, nameOf(el)));
+    }
+  }
+  for (const line of evolveLines) lines.push(line);
+  for (const edge of map.edges) {
+    const from = names.get(edge.from) ?? edge.from;
+    const to = names.get(edge.to) ?? edge.to;
+    const annotation = edge.label ? `; ${edge.label}` : "";
+    if (edge.edgeType === "dependency") {
+      lines.push(`${from} -> ${to}${annotation}`);
+    } else {
+      const op = edge.flowValue ? `+'${edge.flowValue}'${edge.bidirectional ? "<>" : ">"}` : edge.bidirectional ? "+<>" : "+>";
+      lines.push(`${from} ${op} ${to}${annotation}`);
+    }
+  }
+  if (map.rawPassthrough) {
+    const emitted = /* @__PURE__ */ new Set();
+    if (map.config.evolutionLabels) emitted.add("evolution");
+    if (map.config.yAxisLabel) emitted.add("y-axis");
+    for (const raw of map.rawPassthrough) {
+      if (emitted.has(raw.trim().split(/\s+/)[0])) continue;
+      lines.push(raw);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function elementLine(el, name) {
+  const p = el.position;
+  switch (el.elementType) {
+    case "anchor":
+      return `anchor ${name} [${r(p.visibility)}, ${r(p.evolution)}]${offsetSuffix(el.labelOffset)}`;
+    case "component":
+      return `component ${name} [${r(p.visibility)}, ${r(p.evolution)}]${decoratorSuffix(el.decorators)}${offsetSuffix(el.labelOffset)}`;
+    case "note":
+      return `note ${name.replace(/\n/g, "\\n")} [${r(p.visibility)}, ${r(p.evolution)}]${el.color ? ` (color ${el.color})` : ""}`;
+    case "pipeline":
+      return `pipeline ${name} [${r(el.evolutionStart)}, ${r(el.evolutionEnd)}]`;
+    case "submap":
+      return `submap ${name} [${r(p.visibility)}, ${r(p.evolution)}]`;
+    case "annotation":
+      return `annotation ${el.number} [${r(p.visibility)}, ${r(p.evolution)}] ${el.text}`;
+    case "accelerator":
+      return `${el.direction === "deaccelerate" ? "deaccelerator" : "accelerator"} ${name} [${r(p.visibility)}, ${r(p.evolution)}]`;
+    case "attitude":
+      return `${el.kind} [${r(p.visibility)}, ${r(p.evolution)}] ${r(el.width)} ${r(el.height)}`;
+  }
+}
+function evolveLine(el, name) {
+  const mv = el.movement;
+  const label = mv.newLabel ? `${name}->${mv.newLabel}` : name;
+  const method = mv.method ? ` (${mv.method})` : "";
+  return `evolve ${label} ${r(mv.targetEvolution)}${method}`;
+}
+
+Object.defineProperty(exports, "loadMap", {
+  enumerable: true,
+  get: function () { return wardleySchemaModel.loadMap; }
+});
+Object.defineProperty(exports, "mapFromJSON", {
+  enumerable: true,
+  get: function () { return wardleySchemaModel.parseMapJSON; }
+});
+Object.defineProperty(exports, "mapToJSON", {
+  enumerable: true,
+  get: function () { return wardleySchemaModel.serializeMap; }
+});
+exports.keywordOf = keywordOf;
+exports.parseCoords = parseCoords;
+exports.parseDSL = parseDSL;
+exports.parseDecorators = parseDecorators;
+exports.parseLabelOffset = parseLabelOffset;
+exports.serializeDSL = serializeDSL;
+exports.slug = slug;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map