@glossarist/concept-browser 0.7.95 → 0.7.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.95",
+  "version": "0.7.96",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

package/src/__tests__/sphere-math.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { hashSeed, expandParams, portSide, portPoint, idToUriGet, visibleNodeIds } from '../utils/sphere-math';
+import type { SphereHyperedgeLike } from '../utils/sphere-math';
 
 describe('sphere-math', () => {
   describe('hashSeed', () => {
@@ -148,6 +149,30 @@ describe('sphere-math', () => {
       expect(visible.has('a')).toBe(false);
     });
 
+    it('hyperedge member with no bilateral edges stays visible while its bundle is not muted', () => {
+      const nodes = [focus, a, b];
+      const links: Array<{ source: string; target: string; type: string }> = [];
+      const hyperedges: SphereHyperedgeLike[] = [
+        { comprehensive: 'focus', members: ['a', 'b'], muteKey: '__partitive__' },
+      ];
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set(), hyperedges);
+      expect(visible.has('focus')).toBe(true);
+      expect(visible.has('a')).toBe(true);
+      expect(visible.has('b')).toBe(true);
+    });
+
+    it('hyperedge members disappear when the bundle is muted', () => {
+      const nodes = [focus, a, b];
+      const links: Array<{ source: string; target: string; type: string }> = [];
+      const hyperedges: SphereHyperedgeLike[] = [
+        { comprehensive: 'focus', members: ['a', 'b'], muteKey: '__partitive__' },
+      ];
+      const visible = visibleNodeIds(nodes, links, new Set(['__partitive__']), new Set(), hyperedges);
+      expect(visible.has('focus')).toBe(true);
+      expect(visible.has('a')).toBe(false);
+      expect(visible.has('b')).toBe(false);
+    });
+
     it('all-visible when no mutes are set', () => {
       const nodes = [focus, a, b, c, d];
       const links = buildLinks([

package/src/components/RelationSphere.vue

@@ -97,6 +97,13 @@ const mutedRegisters = ref<Set<string>>(new Set());
 const panelOpen = ref(true);
 const MAX_NODES = 36;
 
+/** Convert a concept URI to the internal `${registerId}/${conceptId}` node ID. */
+function uriToNodeId(uri: string): string {
+  const parsed = UriRouter.parseUri(uri);
+  if (parsed) return `${parsed.registerId}/${parsed.conceptId}`;
+  return uri;
+}
+
 /* Sphere-display language. Defaults to the i18n UI locale (which reads
    localStorage) so e.g. a user returning in French mode sees French
    terms by default. The user can override via the Language selector. */
@@ -735,8 +742,29 @@ function renderDOM() {
 
   /* Cards with no visible edges (after applying type + register mutes)
      float with no connections — hide them so toggling a relation type
-     cleans up orphaned cards. Focus node (depth 0) always renders. */
-  const visibleIds = visibleNodeIds(nodes, links, mutedTypes.value, mutedRegisters.value);
+     cleans up orphaned cards. Focus node (depth 0) always renders.
+     Hyperedge members are always visible while their bundle is not
+     muted, even when they have no bilateral edges, so the rake has a
+     card to point at. */
+  const hyperedgesForVisibility = [
+    ...(props.partitiveRelations ?? []).map(rel => ({
+      comprehensive: uriToNodeId(rel.comprehensive),
+      members: rel.partitives.map(m => uriToNodeId(m.uri)),
+      muteKey: '__partitive__',
+    })),
+    ...(props.genericRelations ?? []).map(rel => ({
+      comprehensive: uriToNodeId(rel.comprehensive),
+      members: rel.members.map(m => uriToNodeId(m.uri)),
+      muteKey: '__generic__',
+    })),
+  ];
+  const visibleIds = visibleNodeIds(
+    nodes,
+    links,
+    mutedTypes.value,
+    mutedRegisters.value,
+    hyperedgesForVisibility,
+  );
 
   for (const n of nodes) {
     if (!visibleIds.has(n.id)) continue;

package/src/utils/sphere-math.ts

@@ -65,13 +65,27 @@ export interface SphereLinkLike {
   type: string;
 }
 
+export interface SphereHyperedgeLike {
+  /** Node ID of the comprehensive concept. */
+  comprehensive: string;
+  /** Node IDs of the member concepts. */
+  members: readonly string[];
+  /** Mute key — when present in mutedTypes, the whole hyperedge is hidden. */
+  muteKey?: string;
+}
+
 /**
  * IDs of nodes that should render given the current mute state.
  *
  * The focus node (depth 0) is always visible. Every other node must have
  * at least one edge whose type is not muted AND whose other endpoint is
- * not in a muted register — otherwise the card floats with no connections
- * and should disappear when its relations are hidden.
+ * not in a muted register — OR be a member of a non-muted hyperedge —
+ * otherwise the card floats with no connections and should disappear
+ * when its relations are hidden.
+ *
+ * Hyperedge membership counts as a "visible edge" because rake bundles
+ * are the connection: a member with no bilateral edges still needs its
+ * card rendered so the rake has something to point at.
  *
  * Extracted as a pure function so the visibility contract can be tested
  * without mounting the sphere component.
@@ -81,10 +95,19 @@ export function visibleNodeIds(
   links: readonly SphereLinkLike[],
   mutedTypes: ReadonlySet<string>,
   mutedRegisters: ReadonlySet<string>,
+  hyperedges: readonly SphereHyperedgeLike[] = [],
 ): Set<string> {
   const byId = new Map<string, SphereNodeLike>();
   for (const n of nodes) byId.set(n.id, n);
 
+  /* Pre-compute node IDs that participate in a non-muted hyperedge. */
+  const hyperedgeNodeIds = new Set<string>();
+  for (const he of hyperedges) {
+    if (he.muteKey && mutedTypes.has(he.muteKey)) continue;
+    hyperedgeNodeIds.add(he.comprehensive);
+    for (const m of he.members) hyperedgeNodeIds.add(m);
+  }
+
   const visible = new Set<string>();
   for (const n of nodes) {
     if (n.depth === 0) {
@@ -92,6 +115,10 @@ export function visibleNodeIds(
       continue;
     }
     if (mutedRegisters.has(n.register)) continue;
+    if (hyperedgeNodeIds.has(n.id)) {
+      visible.add(n.id);
+      continue;
+    }
     for (const l of links) {
       if (mutedTypes.has(l.type)) continue;
       const otherId = l.source === n.id ? l.target : l.target === n.id ? l.source : null;
@@ -106,3 +133,4 @@ export function visibleNodeIds(
   return visible;
 }
 
+