libpetri 1.8.5 → 2.0.0

package/dist/doclet/index.js

@@ -1,3 +1,11 @@
+import {
+  FONT,
+  dotExport,
+  nodeStyle,
+  sanitize
+} from "../chunk-4L6JVKH4.js";
+import "../chunk-FN773SSE.js";
+
 // src/doclet/petri-net-plugin.ts
 import {
   JSX
@@ -39,29 +47,53 @@ async function resolveNet(reference, sourceFilePath) {
   if (!mod) return null;
   const exported = mod[exportName];
   if (exported == null) return null;
-  let net;
+  let value;
   if (isCall) {
     if (typeof exported !== "function") return null;
     const result = exported();
-    net = "net" in result ? result.net : result;
+    if (result !== null && typeof result === "object" && "net" in result && isPetriNetLike(result.net)) {
+      value = result.net;
+    } else {
+      value = result;
+    }
   } else {
-    net = exported;
+    value = exported;
   }
-  if (typeof net?.name !== "string" || !(net?.transitions instanceof Set)) {
-    return null;
+  return classify(value);
+}
+function classify(value) {
+  if (value === null || typeof value !== "object") return null;
+  if (isInstanceLike(value)) {
+    const inst = value;
+    return { kind: "instance", value: inst, title: `${inst.def.name} :: ${inst.prefix}` };
   }
-  return { net, title: net.name };
+  if (isSubnetDefLike(value)) {
+    const def = value;
+    return { kind: "subnet", value: def, title: def.name };
+  }
+  if (isPetriNetLike(value)) {
+    const net = value;
+    return { kind: "net", value: net, title: net.name };
+  }
+  return null;
 }
-
-// src/doclet/svg-renderer.ts
-async function dotToSvg(dot) {
-  const { instance } = await import("@viz-js/viz");
-  const viz = await instance();
-  let svg = viz.renderString(dot, { format: "svg", engine: "dot" });
-  const svgStart = svg.indexOf("<svg");
-  if (svgStart > 0) svg = svg.substring(svgStart);
-  svg = svg.replace(/\s+(?:width|height)="[^"]*"/g, "");
-  return svg;
+function isPetriNetLike(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.name === "string" && candidate.transitions instanceof Set;
+}
+function isSubnetDefLike(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  if (typeof candidate.name !== "string") return false;
+  if (!isPetriNetLike(candidate.body)) return false;
+  const iface = candidate.iface;
+  return iface !== void 0 && iface !== null && iface.ports instanceof Map && iface.channels instanceof Map;
+}
+function isInstanceLike(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.prefix === "string" && isSubnetDefLike(candidate.def) && isPetriNetLike(candidate.renamedBody);
 }
 
 // src/doclet/diagram-renderer.ts
@@ -83,41 +115,351 @@ function js() {
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function renderSvg(title, svgContent, dotSource) {
-  const titleHtml = title ? `<h4>${escapeHtml(title)}</h4>
+function escapeAttr(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderSvg(title, dotSource) {
+  return renderInternal(
+    title ?? null,
+    /* headerHtml */
+    null,
+    dotSource
+  );
+}
+function renderSubnetSvg(title, headerHtml, dotSource) {
+  return renderInternal(title ?? null, headerHtml, dotSource);
+}
+var diagramIdCounter = 0;
+function renderInternal(title, headerHtml, dotSource) {
+  const titleHtml = title !== null ? `<h4>${escapeHtml(title)}</h4>
 ` : "";
-  const summaryText = title ? "View DOT Source" : "View Source";
+  const summaryText = title !== null ? "View DOT Source" : "View Source";
+  const diagramClass = headerHtml !== null ? "petrinet-diagram subnet-diagram" : "petrinet-diagram";
+  const headerBlock = headerHtml !== null ? headerHtml : "";
+  const dotAttr = escapeAttr(dotSource);
+  const containerId = `libpetri-diagram-${++diagramIdCounter}`;
   return `<style>${css()}</style>
-<script>if(!window._petriNetDiagramsInit){window._petriNetDiagramsInit=true;
+<script>if(!window._libpetriViewerInit){window._libpetriViewerInit=true;
 ${js()}
 }</script>
-<div class="petrinet-diagram">
-${titleHtml}<div class="diagram-container">
-<div class="diagram-controls">
-<button class="diagram-btn btn-reset" title="Reset zoom">Reset</button>
-<button class="diagram-btn btn-fullscreen" onclick="PetriNetDiagrams.toggleFullscreen(this)">Fullscreen</button>
-</div>
-${svgContent}
-</div>
+<div class="${diagramClass}">
+${titleHtml}${headerBlock}<div class="diagram-container" id="${containerId}" data-libpetri-diagram="true" data-dot="${dotAttr}"></div>
 <details>
 <summary>${summaryText}</summary>
 <pre><code>${escapeHtml(dotSource)}</code></pre>
 </details>
-</div>`;
+</div>
+<script>(function(){function mount(){var el=document.getElementById(${JSON.stringify(containerId)});if(!el)return;if(el.dataset.libpetriMounted)return;if(!window.LibpetriViewer||typeof window.LibpetriViewer.mount!=='function'){return setTimeout(mount,30);}el.dataset.libpetriMounted='1';try{window.LibpetriViewer.mount(el.dataset.dot,el,{chrome:true});}catch(e){console.error('[libpetri] mount failed',e);}}if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',mount);}else{mount();}})();</script>`;
+}
+
+// src/doclet/subnet-header.ts
+function forSubnetDef(def, interfaceOnly2) {
+  const sb = [];
+  sb.push(`<div class="subnet-header">
+`);
+  sb.push(`  <div class="subnet-header-row">
+`);
+  sb.push(`    <span class="subnet-header-label">subnet</span>
+`);
+  sb.push(`    <span class="subnet-header-name">${escapeHtml(def.name)}</span>
+`);
+  sb.push(`    <span class="subnet-header-param">&lt;?&gt;</span>
+`);
+  if (interfaceOnly2) {
+    sb.push(`    <span class="subnet-header-badge subnet-header-badge-interface">interface only</span>
+`);
+  }
+  sb.push(`  </div>
+`);
+  sb.push(renderPortChannelBadges(def.iface));
+  sb.push(`</div>
+`);
+  return sb.join("");
+}
+function forInstance(instance) {
+  const def = instance.def;
+  const sb = [];
+  sb.push(`<div class="subnet-header">
+`);
+  sb.push(`  <div class="subnet-header-row">
+`);
+  sb.push(`    <span class="subnet-header-label">instance</span>
+`);
+  sb.push(`    <span class="subnet-header-name">${escapeHtml(instance.prefix)}</span>
+`);
+  sb.push(`    <span class="subnet-header-of">of</span>
+`);
+  sb.push(`    <span class="subnet-header-name">${escapeHtml(def.name)}</span>
+`);
+  const params = instance.params;
+  if (params !== null && params !== void 0) {
+    sb.push(`    <span class="subnet-header-params">params=${escapeHtml(String(params))}</span>
+`);
+  }
+  sb.push(`  </div>
+`);
+  sb.push(renderPortChannelBadges(def.iface));
+  sb.push(`</div>
+`);
+  return sb.join("");
+}
+function renderPortChannelBadges(iface) {
+  if (iface.ports.size === 0 && iface.channels.size === 0) {
+    return "";
+  }
+  const sb = [];
+  sb.push(`  <div class="subnet-header-badges">
+`);
+  for (const port of iface.ports.values()) {
+    const kind = portKind(port);
+    sb.push(`    <span class="interface-port-badge interface-port-badge-${kind}">`);
+    sb.push(`<span class="badge-direction">${kind}</span>`);
+    sb.push(`<span class="badge-name">${escapeHtml(port.name)}</span>`);
+    sb.push(`</span>
+`);
+  }
+  for (const channel of iface.channels.values()) {
+    sb.push(`    <span class="interface-channel-badge">`);
+    sb.push(`<span class="badge-direction">channel</span>`);
+    sb.push(`<span class="badge-name">${escapeHtml(channel.name)}</span>`);
+    sb.push(`</span>
+`);
+  }
+  sb.push(`  </div>
+`);
+  return sb.join("");
+}
+function portKind(port) {
+  return port.direction;
+}
+
+// src/doclet/subnet-dot-export.ts
+function fullBody(def) {
+  let dot = dotExport(def.body);
+  const portIds = portNodeIds(def.iface);
+  const channelIds = channelNodeIds(def.iface);
+  for (const portId of portIds) {
+    dot = restyleNode(dot, portId, nodeStyle("interface-port"));
+  }
+  for (const chId of channelIds) {
+    dot = restyleNode(dot, chId, nodeStyle("sync-channel"));
+  }
+  if (portIds.size > 0 || channelIds.size > 0) {
+    let iface = "";
+    iface += `    subgraph cluster_iface_${sanitize(def.name)} {
+`;
+    iface += `        label="interface";
+`;
+    iface += `        style="rounded,dashed";
+`;
+    iface += `        bgcolor="#F0F6FF";
+`;
+    iface += `        penwidth=2;
+`;
+    for (const id of portIds) {
+      iface += `        ${id};
+`;
+    }
+    for (const id of channelIds) {
+      iface += `        ${id};
+`;
+    }
+    iface += `    }
+`;
+    const lastBrace = dot.lastIndexOf("}");
+    if (lastBrace > 0) {
+      dot = dot.substring(0, lastBrace) + iface + dot.substring(lastBrace);
+    }
+  }
+  return dot;
+}
+function interfaceOnly(def) {
+  const sb = [];
+  sb.push(`digraph ${sanitize(def.name)} {
+`);
+  sb.push(`    rankdir=LR;
+`);
+  sb.push(`    nodesep=0.5;
+`);
+  sb.push(`    ranksep=0.6;
+`);
+  sb.push(`    fontname="${FONT.family}";
+`);
+  sb.push(`    node [fontname="${FONT.family}", fontsize=12];
+`);
+  sb.push(`    edge [fontname="${FONT.family}", fontsize=10];
+`);
+  sb.push("\n");
+  const stubId = "stub_" + sanitize(def.name);
+  const inputs = [];
+  const outputs = [];
+  const inouts = [];
+  for (const port of def.iface.ports.values()) {
+    switch (port.direction) {
+      case "input":
+        inputs.push(port);
+        break;
+      case "output":
+        outputs.push(port);
+        break;
+      case "inout":
+        inouts.push(port);
+        break;
+    }
+  }
+  for (const port of inputs) emitPortNode(sb, port, "input");
+  for (const port of outputs) emitPortNode(sb, port, "output");
+  for (const port of inouts) emitPortNode(sb, port, "inout");
+  const syncStyle = nodeStyle("sync-channel");
+  for (const ch of def.iface.channels.values()) {
+    sb.push(`    ${channelNodeId(ch)} [`);
+    sb.push(`label="\u21C4 ${escapeLabel(ch.name)}", `);
+    sb.push(`shape=${syncStyle.shape}, `);
+    sb.push(`style="filled", `);
+    sb.push(`fillcolor="${syncStyle.fill}", `);
+    sb.push(`color="${syncStyle.stroke}", `);
+    sb.push(`penwidth=${trimNumber(syncStyle.penwidth)}`);
+    sb.push(`];
+`);
+  }
+  sb.push(`    ${stubId} [`);
+  sb.push(`label="${escapeLabel(def.name)}\\n(internals omitted)", `);
+  sb.push(`shape=box, style="filled,dashed,rounded", `);
+  sb.push(`fillcolor="#FFFFFF", color="#666666", penwidth=1, `);
+  sb.push(`fontsize=11`);
+  sb.push(`];
+`);
+  sb.push("\n");
+  for (const port of inputs) {
+    sb.push(`    ${portNodeId(port)} -> ${stubId} [color="#1d4ed8", arrowhead=normal];
+`);
+  }
+  for (const port of outputs) {
+    sb.push(`    ${stubId} -> ${portNodeId(port)} [color="#1d4ed8", arrowhead=normal];
+`);
+  }
+  for (const port of inouts) {
+    sb.push(`    ${portNodeId(port)} -> ${stubId} [color="#1d4ed8", arrowhead=normalnormal, dir=both];
+`);
+  }
+  for (const ch of def.iface.channels.values()) {
+    sb.push(`    ${channelNodeId(ch)} -> ${stubId} [color="#6d28d9", arrowhead=normal, style=dashed];
+`);
+  }
+  sb.push(`}
+`);
+  return sb.join("");
+}
+function emitPortNode(sb, port, direction) {
+  const style = nodeStyle("interface-port");
+  sb.push(`    ${portNodeId(port)} [`);
+  sb.push(`label="${escapeLabel(port.name)}", `);
+  sb.push(`xlabel="${escapeLabel(direction)}", `);
+  sb.push(`shape=${style.shape}, `);
+  sb.push(`style="filled,${style.style ?? "solid"}", `);
+  sb.push(`fillcolor="${style.fill}", `);
+  sb.push(`color="${style.stroke}", `);
+  sb.push(`penwidth=${trimNumber(style.penwidth)}`);
+  if (style.width !== void 0) {
+    sb.push(`, width=${trimNumber(style.width)}, fixedsize=true`);
+  }
+  sb.push(`];
+`);
+}
+function portNodeId(port) {
+  return "p_" + sanitize(port.place.name);
+}
+function channelNodeId(ch) {
+  return "t_" + sanitize(ch.transition.name);
+}
+function portNodeIds(iface) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const port of iface.ports.values()) ids.add(portNodeId(port));
+  return ids;
+}
+function channelNodeIds(iface) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const ch of iface.channels.values()) ids.add(channelNodeId(ch));
+  return ids;
+}
+function restyleNode(dot, nodeId, style) {
+  const marker = nodeId + " [";
+  let start = dot.indexOf("\n    " + marker);
+  if (start < 0) start = dot.indexOf("    " + marker);
+  if (start < 0) return dot;
+  if (dot.charAt(start) === "\n") start += 1;
+  const lineEnd = dot.indexOf("];", start);
+  if (lineEnd < 0) return dot;
+  let line = dot.substring(start, lineEnd + 2);
+  line = replaceAttr(line, "fillcolor", style.fill);
+  line = replaceAttr(line, "color", style.stroke);
+  line = replaceAttr(line, "penwidth", trimNumber(style.penwidth));
+  if (style.style !== void 0) {
+    line = replaceAttr(line, "style", `"filled,${style.style}"`);
+  }
+  return dot.substring(0, start) + line + dot.substring(lineEnd + 2);
+}
+function replaceAttr(line, key, value) {
+  const quotedPat = key + '="';
+  const qStart = findAttrStart(line, quotedPat);
+  if (qStart >= 0) {
+    const valStart2 = qStart + quotedPat.length;
+    const valEnd2 = line.indexOf('"', valStart2);
+    if (valEnd2 < 0) return line;
+    let v = value;
+    if (v.startsWith('"') && v.endsWith('"') && v.length >= 2) {
+      v = v.substring(1, v.length - 1);
+    }
+    return line.substring(0, valStart2) + v + line.substring(valEnd2);
+  }
+  const unquoted = key + "=";
+  const uStart = findAttrStart(line, unquoted);
+  if (uStart < 0) return line;
+  const valStart = uStart + unquoted.length;
+  let valEnd = valStart;
+  while (valEnd < line.length) {
+    const c = line.charAt(valEnd);
+    if (c === "," || c === "]") break;
+    valEnd++;
+  }
+  return line.substring(0, valStart) + value + line.substring(valEnd);
+}
+function findAttrStart(line, pattern) {
+  let from = 0;
+  while (from < line.length) {
+    const idx = line.indexOf(pattern, from);
+    if (idx < 0) return -1;
+    if (idx === 0) return idx;
+    const prev = line.charAt(idx - 1);
+    if (!/[A-Za-z0-9_]/.test(prev)) return idx;
+    from = idx + 1;
+  }
+  return -1;
+}
+function trimNumber(d) {
+  if (Number.isInteger(d)) return String(d);
+  return String(d);
+}
+function escapeLabel(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 
 // src/doclet/petri-net-plugin.ts
 async function getDotExport() {
-  const mod = await import("../dot-exporter-3CVCH6J4.js");
+  const mod = await import("../dot-exporter-PMHOQHZ3.js");
   return mod.dotExport;
 }
-var TAG_NAME = "@petrinet";
+var TAG_PETRINET = "@petrinet";
+var TAG_SUBNET = "@subnet";
 var htmlCache = /* @__PURE__ */ new Map();
 function load(app) {
   app.on("bootstrapEnd", () => {
     const blockTags = app.options.getValue("blockTags");
-    if (!blockTags.includes(TAG_NAME)) {
-      app.options.setValue("blockTags", [...blockTags, TAG_NAME]);
+    const additions = [];
+    if (!blockTags.includes(TAG_PETRINET)) additions.push(TAG_PETRINET);
+    if (!blockTags.includes(TAG_SUBNET)) additions.push(TAG_SUBNET);
+    if (additions.length > 0) {
+      app.options.setValue("blockTags", [...blockTags, ...additions]);
     }
   });
   app.renderer.preRenderAsyncJobs.push(async (output) => {
@@ -128,7 +470,7 @@ function load(app) {
     const cached = htmlCache.get(reflection.id);
     if (!cached) return JSX.createElement(JSX.Raw, { html: "" });
     for (const tag of comment.blockTags) {
-      if (tag.tag === TAG_NAME) {
+      if (tag.tag === TAG_PETRINET || tag.tag === TAG_SUBNET) {
         tag.skipRendering = true;
       }
     }
@@ -140,19 +482,19 @@ async function processProject(app, project) {
   for (const reflection of reflections) {
     const comment = reflection.comment;
     if (!comment) continue;
-    const petrinetTags = comment.blockTags.filter(
-      (tag) => tag.tag === TAG_NAME
-    );
-    if (petrinetTags.length === 0) continue;
-    for (const tag of petrinetTags) {
+    for (const tag of comment.blockTags) {
+      const isPetrinet = tag.tag === TAG_PETRINET;
+      const isSubnet = tag.tag === TAG_SUBNET;
+      if (!isPetrinet && !isSubnet) continue;
       const reference = tagContent(tag);
       try {
-        const html = await generateDiagram(reference, reflection, app);
+        const html = isSubnet ? await generateInterfaceOnly(reference, reflection) : await generateDiagram(reference, reflection);
         const existing = htmlCache.get(reflection.id) ?? "";
         htmlCache.set(reflection.id, existing + html);
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        app.logger.warn(`@petrinet error for ${reflection.getFriendlyFullName()}: ${msg}`);
+        const tagName = isSubnet ? "@subnet" : "@petrinet";
+        app.logger.warn(`${tagName} error for ${reflection.getFriendlyFullName()}: ${msg}`);
         const html = errorHtml(`Error generating diagram for '${reference}': ${msg}`);
         const existing = htmlCache.get(reflection.id) ?? "";
         htmlCache.set(reflection.id, existing + html);
@@ -160,7 +502,7 @@ async function processProject(app, project) {
     }
   }
 }
-async function generateDiagram(reference, reflection, app) {
+async function generateDiagram(reference, reflection) {
   const trimmed = reference.trim();
   if (!trimmed) {
     return errorHtml(`Empty @petrinet reference on ${reflection.getFriendlyFullName()}`);
@@ -171,21 +513,64 @@ async function generateDiagram(reference, reflection, app) {
   }
   const resolved = await resolveNet(trimmed, sourceFile);
   if (!resolved) {
-    return errorHtml(`Cannot resolve PetriNet: ${trimmed}`);
-  }
-  const dotExport = await getDotExport();
-  const dot = dotExport(resolved.net);
-  try {
-    const svg = await dotToSvg(dot);
-    return renderSvg(resolved.title, svg, dot);
-  } catch (e) {
-    app.logger.warn(`SVG rendering failed, falling back to DOT source: ${e}`);
-    return renderSvg(
-      resolved.title,
-      `<pre><code>${escapeHtml(dot)}</code></pre>`,
-      dot
-    );
+    return errorHtml(`Cannot resolve PetriNet/SubnetDef/Instance: ${trimmed}`);
   }
+  return await renderResolved(
+    resolved,
+    /* interfaceOnly */
+    false
+  );
+}
+async function generateInterfaceOnly(reference, reflection) {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    return errorHtml(`Empty @subnet reference on ${reflection.getFriendlyFullName()}`);
+  }
+  const sourceFile = getSourceFilePath(reflection);
+  if (!sourceFile) {
+    return errorHtml(`Cannot determine source file for ${reflection.getFriendlyFullName()}`);
+  }
+  const resolved = await resolveNet(trimmed, sourceFile);
+  if (!resolved) {
+    return errorHtml(`Cannot resolve SubnetDef: ${trimmed}`);
+  }
+  return await renderResolved(
+    resolved,
+    /* interfaceOnly */
+    true
+  );
+}
+async function renderResolved(resolved, interfaceOnly2) {
+  switch (resolved.kind) {
+    case "net": {
+      const dotExport2 = await getDotExport();
+      const dot = dotExport2(resolved.value);
+      return renderDiagramHtml(
+        resolved.title,
+        dot,
+        /* header */
+        null
+      );
+    }
+    case "subnet": {
+      const dot = interfaceOnly2 ? interfaceOnly(resolved.value) : fullBody(resolved.value);
+      const header = forSubnetDef(resolved.value, interfaceOnly2);
+      const title = resolved.value.name + (interfaceOnly2 ? " (interface)" : "");
+      return renderDiagramHtml(title, dot, header);
+    }
+    case "instance": {
+      const dotExport2 = await getDotExport();
+      const dot = dotExport2(resolved.value.renamedBody);
+      const header = forInstance(resolved.value);
+      return renderDiagramHtml(resolved.title, dot, header);
+    }
+  }
+}
+function renderDiagramHtml(title, dot, header) {
+  if (header !== null) {
+    return renderSubnetSvg(title, header, dot);
+  }
+  return renderSvg(title, dot);
 }
 function tagContent(tag) {
   return tag.content.map((part) => part.text).join("").trim();
@@ -205,11 +590,27 @@ function errorHtml(message) {
 <strong>@petrinet Error:</strong> ${escapeHtml(message)}
 </div>`;
 }
+
+// src/doclet/svg-renderer.ts
+async function dotToSvg(dot) {
+  const { instance } = await import("@viz-js/viz");
+  const viz = await instance();
+  let svg = viz.renderString(dot, { format: "svg", engine: "dot" });
+  const svgStart = svg.indexOf("<svg");
+  if (svgStart > 0) svg = svg.substring(svgStart);
+  svg = svg.replace(/\s+(?:width|height)="[^"]*"/g, "");
+  return svg;
+}
 export {
   dotToSvg,
   escapeHtml,
+  forInstance,
+  forSubnetDef,
   load,
+  renderSubnetSvg,
   renderSvg,
-  resolveNet
+  resolveNet,
+  fullBody as subnetFullBody,
+  interfaceOnly as subnetInterfaceOnly
 };
 //# sourceMappingURL=index.js.map