Information for ' + (itemData.itemType || 'item') + ' type "' + (itemData.key || itemData.label || '') + '" is not currently available.
';
+ }
+ popupContent.innerHTML = contentHtml;
+ // Position to the left of the button; measure after making visible so width is known
+ popup.style.left = '-9999px';
+ popup.classList.add('visible');
+ const popupRect = popup.getBoundingClientRect();
+ popup.style.left = (rect.left - containerRect.left - popupRect.width - 10) + 'px';
+ // If that goes off the left edge, fall back to right of the button
+ if (rect.left - popupRect.width - 10 < 0) {
+ popup.style.left = (rect.right - containerRect.left + 10) + 'px';
+ }
+ if (popupRect.bottom > window.innerHeight) popup.style.top = (rect.bottom - containerRect.top - popupRect.height + 10) + 'px';
+ }
+
+ function hideInfoPopup() {
+ document.getElementById('info-popup').classList.remove('visible');
+ }
+"""
+
+_INFO_POPUP_HTML = """
+
+
+
i
+
+
+
+
+"""
+
+
+# ---------------------------------------------------------------------------
+# Library / tree panel
+# ---------------------------------------------------------------------------
+
+
+def _build_tree_nodes(project_url: str, project: dict, info_data: dict) -> list:
+ """Equivalent to buildTreeNodes() in extension.ts."""
+ children = []
+
+ def _build_tooltip(doc, link):
+ return json.dumps({"doc": doc or "", "link": link or ""})
+
+ # Top-level contents
+ for name in (project.get("contents") or {}).keys():
+ basename = name.split("/")[-1]
+ content_type = basename.split(".")[0]
+ info = (info_data.get("content") or {}).get(content_type)
+ info_text = (
+ _build_tooltip(info.get("doc"), info.get("link", "")) if info else None
+ )
+ children.append(
+ {
+ "key": basename,
+ "infoData": info_text,
+ "projectUrl": project_url,
+ "itemType": "content",
+ }
+ )
+
+ # Top-level artifacts
+ for artifact_type, artifact_data in (project.get("artifacts") or {}).items():
+ info = (info_data.get("artifact") or {}).get(artifact_type)
+ info_text = (
+ _build_tooltip(info.get("doc"), info.get("link", "")) if info else None
+ )
+ if isinstance(artifact_data, str):
+ children.append(
+ {
+ "key": artifact_type,
+ "infoData": info_text,
+ "projectUrl": project_url,
+ "itemType": "artifact",
+ "qname": artifact_type,
+ }
+ )
+ elif isinstance(artifact_data, dict):
+ for name in artifact_data.keys():
+ children.append(
+ {
+ "key": f"{artifact_type}.{name}",
+ "infoData": info_text,
+ "projectUrl": project_url,
+ "itemType": "artifact",
+ "qname": f"{artifact_type}.{name}",
+ }
+ )
+
+ # Specs
+ for spec_name, spec_data in (project.get("specs") or {}).items():
+ info = (info_data.get("specs") or {}).get(spec_name)
+ info_text = (
+ _build_tooltip(info.get("doc"), info.get("link", "")) if info else None
+ )
+ spec_children = []
+ for artifact_type, artifact_data in (spec_data.get("_artifacts") or {}).items():
+ art_info = (info_data.get("artifact") or {}).get(artifact_type)
+ art_info_text = (
+ _build_tooltip(art_info.get("doc"), art_info.get("link", ""))
+ if art_info
+ else None
+ )
+ if isinstance(artifact_data, str):
+ spec_children.append(
+ {
+ "key": artifact_type,
+ "infoData": art_info_text,
+ "projectUrl": project_url,
+ "itemType": "artifact",
+ "qname": f"{spec_name}.{artifact_type}",
+ }
+ )
+ elif isinstance(artifact_data, dict):
+ for name in artifact_data.keys():
+ spec_children.append(
+ {
+ "key": f"{artifact_type}.{name}",
+ "infoData": art_info_text,
+ "projectUrl": project_url,
+ "itemType": "artifact",
+ "qname": f"{spec_name}.{artifact_type}.{name}",
+ }
+ )
+ node = {
+ "key": spec_name,
+ "infoData": info_text,
+ "projectUrl": project_url,
+ "itemType": "spec",
+ }
+ if spec_children:
+ node["children"] = spec_children
+ children.append(node)
+
+ return children
+
+
+def _generate_tree_html(node: dict, level: int = 0) -> str:
+ """Equivalent to generateTreeHTML() in extension.ts."""
+ html = ""
+ for child in node.get("children") or []:
+ has_children = bool(child.get("children"))
+ node_class = _get_node_class(child)
+ icon_class = "tree-icon expandable" if has_children else "tree-icon leaf"
+ has_info = child.get("itemType") in ("content", "artifact", "spec")
+ is_artifact = child.get("itemType") == "artifact"
+ item_data_json = _escape(json.dumps(child))
+ key_text = _escape(str(child.get("key", "")))
+ make_btn = (
+ f''
+ if is_artifact
+ else ""
+ )
+ info_btn = (
+ f''
+ if has_info
+ else ""
+ )
+ children_html = ""
+ if has_children:
+ children_html = f'
{_generate_tree_html(child, level + 1)}
'
+ html += f"""
+
+
+
+ {key_text}
+ {make_btn}
+ {info_btn}
+
+ {children_html}
+
"""
+ return html
+
+
+def _get_node_class(node: dict) -> str:
+ if node.get("isProject"):
+ return "project-node"
+ elif node.get("itemType") == "content":
+ return "content-node"
+ elif node.get("itemType") == "artifact":
+ return "artifact-node"
+ elif node.get("itemType") == "spec":
+ return "spec-node"
+ elif node.get("children"):
+ return "folder-node"
+ return ""
+
+
+def get_library_html(
+ library_data: dict,
+ spec_names: list[str],
+ scroll_to_project_url: str | None = None,
+) -> str:
+ """Generate the Library panel HTML.
+
+ Equivalent to getTreeWebviewContent() in extension.ts.
+
+ Parameters
+ ----------
+ library_data:
+ ``{project_url: project_dict}`` — the full library JSON.
+ spec_names:
+ List of known spec type names for the Create project autocomplete.
+ scroll_to_project_url:
+ If given, this project will be expanded and selected on load.
+ """
+ info_data = _get_info_data()
+
+ # Build tree data
+ project_children = []
+ for project_url, project in library_data.items():
+ pchildren = _build_tree_nodes(project_url, project, info_data)
+ project_basename = project_url.split("/")[-1] or project_url
+ node = {
+ "key": f"{project_basename} ({project_url})",
+ "infoData": project_url,
+ "children": pchildren,
+ "data": project,
+ "isProject": True,
+ }
+ project_children.append(node)
+
+ tree_root = {"key": "projects", "children": project_children}
+ tree_html = _generate_tree_html(tree_root)
+
+ spec_names_json = json.dumps(spec_names)
+ scroll_url_js = (
+ f"'{_escape(scroll_to_project_url)}'" if scroll_to_project_url else "null"
+ )
+
+ return f"""
+
+
+
+
+ Project Library
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {tree_html}
+
+
+
+
+
+
+
+ {_INFO_POPUP_HTML}
+
+
+
Set browser path
+
Open in system file browser
+
Open in VSCode
+
Open in Jupyter
+
Remove from library
+
+
+
+
+
Create Project
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+
+# ---------------------------------------------------------------------------
+# Details panel
+# ---------------------------------------------------------------------------
+
+_SKIP_KEYS = {"klass", "proc", "storage_options", "children", "url"}
+
+
+def _build_tooltip(doc, link):
+ return json.dumps({"doc": doc or "", "link": link or ""})
+
+
+def _build_detail_nodes(
+ obj: Any, role: str, qname_path: str, project_url: str, info_data: dict
+) -> list:
+ """Equivalent to buildNodes() in extension.ts."""
+ if obj is None:
+ return []
+
+ def scalar_label(v):
+ if v is None:
+ return "null"
+ return str(v)
+
+ if isinstance(obj, list):
+ result = []
+ for i, item in enumerate(obj):
+ if item is not None and isinstance(item, dict):
+ result.append(
+ {
+ "label": str(i),
+ "role": role,
+ "children": _build_detail_nodes(
+ item,
+ role,
+ f"{qname_path}.{i}",
+ project_url,
+ info_data,
+ ),
+ }
+ )
+ else:
+ result.append({"label": scalar_label(item), "role": "field"})
+ return result
+
+ if not isinstance(obj, dict):
+ return [{"label": scalar_label(obj), "role": "field"}]
+
+ nodes = []
+ for key, value in obj.items():
+ if key in _SKIP_KEYS:
+ continue
+ child_path = f"{qname_path}.{key}" if qname_path else key
+
+ # Container keys — inline children with correct role
+ if key in ("specs", "_contents", "contents", "_artifacts", "artifacts"):
+ child_role = (
+ "spec"
+ if key == "specs"
+ else "content"
+ if key in ("_contents", "contents")
+ else "artifact"
+ )
+ nodes.extend(
+ _build_detail_nodes(
+ value, child_role, qname_path, project_url, info_data
+ )
+ )
+ continue
+
+ # Artifact special handling
+ if role == "artifact":
+ art_info = (info_data.get("artifact") or {}).get(key)
+ art_info_data = (
+ _build_tooltip(art_info.get("doc"), art_info.get("link", ""))
+ if art_info
+ else None
+ )
+
+ if isinstance(value, str) or value is None:
+ nodes.append(
+ {
+ "label": key,
+ "role": "artifact",
+ "qname": child_path,
+ "projectUrl": project_url,
+ "infoData": art_info_data,
+ "itemType": "artifact",
+ }
+ )
+ elif isinstance(value, dict):
+ entries = list(value.items())
+ all_strings = all(isinstance(v, (str, type(None))) for _, v in entries)
+ if all_strings:
+ named_children = [
+ {
+ "label": name,
+ "role": "artifact",
+ "qname": f"{child_path}.{name}",
+ "projectUrl": project_url,
+ "itemType": "artifact",
+ }
+ for name, _ in entries
+ ]
+ nodes.append(
+ {
+ "label": key,
+ "role": "artifact",
+ "children": named_children or None,
+ "infoData": art_info_data,
+ "itemType": "artifact",
+ }
+ )
+ else:
+ children = _build_detail_nodes(
+ value, "field", child_path, project_url, info_data
+ )
+ nodes.append(
+ {
+ "label": key,
+ "role": "artifact",
+ "qname": child_path,
+ "projectUrl": project_url,
+ "children": children or None,
+ "infoData": art_info_data,
+ "itemType": "artifact",
+ }
+ )
+ continue
+
+ # Scalar leaf
+ if value is None or not isinstance(value, (dict, list)):
+ effective_role = (
+ "content"
+ if role == "content"
+ else ("spec" if role == "spec" else "field")
+ )
+ nodes.append(
+ {
+ "label": key,
+ "value": scalar_label(value),
+ "role": effective_role,
+ }
+ )
+ continue
+ if isinstance(value, list):
+ if all(not isinstance(v, dict) for v in value):
+ array_children = [
+ {"label": scalar_label(v), "role": "field"} for v in value
+ ]
+ effective_role = (
+ "content"
+ if role == "content"
+ else ("spec" if role == "spec" else "field")
+ )
+ nodes.append(
+ {
+ "label": key,
+ "role": effective_role,
+ "children": array_children or None,
+ }
+ )
+ else:
+ nodes.append(
+ {
+ "label": key,
+ "role": role,
+ "children": _build_detail_nodes(
+ value, role, child_path, project_url, info_data
+ ),
+ }
+ )
+ continue
+
+ # Object value
+ children = _build_detail_nodes(value, role, child_path, project_url, info_data)
+ node_info_data = None
+ if role == "spec":
+ info = (info_data.get("specs") or {}).get(key)
+ if info:
+ node_info_data = _build_tooltip(info.get("doc"), info.get("link", ""))
+ elif role == "content":
+ info = (info_data.get("content") or {}).get(key)
+ if info:
+ node_info_data = _build_tooltip(info.get("doc"), "")
+ nodes.append(
+ {
+ "label": key,
+ "role": role,
+ "children": children or None,
+ "infoData": node_info_data,
+ "itemType": role if role not in ("none", "field") else None,
+ }
+ )
+
+ return nodes
+
+
+def _is_leaf_artifact(node: dict) -> bool:
+ if node.get("role") != "artifact" or not node.get("qname"):
+ return False
+ children = node.get("children")
+ if not children:
+ return True
+ return not any(c.get("role") == "artifact" for c in children)
+
+
+def _render_detail_node(node: dict, depth: int) -> str:
+ has_children = bool(node.get("children"))
+ can_make = _is_leaf_artifact(node)
+ has_info_popup = node.get("infoData") is not None and node.get("role") not in (
+ "field",
+ "none",
+ )
+
+ role = node.get("role", "")
+ node_class = "tree-node"
+ if role == "spec":
+ node_class += " spec-node"
+ elif role == "content":
+ node_class += " content-node"
+ elif role == "artifact":
+ node_class += " artifact-node"
+ elif role == "field":
+ node_class += " field-node"
+
+ icon_class = "tree-icon expandable" if has_children else "tree-icon leaf"
+
+ node_data = _escape(
+ json.dumps(
+ {
+ "key": node.get("label", ""),
+ "label": node.get("label", ""),
+ "qname": node.get("qname"),
+ "projectUrl": node.get("projectUrl"),
+ "itemType": node.get("itemType"),
+ "infoData": node.get("infoData"),
+ }
+ )
+ )
+
+ label = node.get("label", "")
+ value = node.get("value")
+ if value is not None:
+ label_html = (
+ f'{_escape(label)}: {_escape(value)}'
+ )
+ else:
+ label_html = _escape(label)
+
+ children_html = ""
+ if has_children:
+ inner = "".join(_render_detail_node(c, depth + 1) for c in node["children"])
+ children_html = (
+ f'