@glossarist/concept-browser 0.7.95 → 0.7.97

package/package.json

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

package/src/__tests__/composables/live-19-pipeline.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { computed } from 'vue';
+import type { Router } from 'vue-router';
+import { useConceptEdges } from '../../composables/use-concept-edges';
+import { useVocabularyStore } from '../../stores/vocabulary';
+import { conceptFromJson } from '../../adapters/model-bridge';
+import type { Manifest, GraphEdge } from '../../adapters/types';
+import { makeManifest, setupPinia } from '../test-helpers';
+import { getFactory, resetFactory } from '../../adapters/factory';
+
+/**
+ * End-to-end pipeline test using the actual live JSON-LD shape from
+ * the deployed oimlsmart/vocab site (vim-2012 concept 1.9).
+ *
+ * Reproduces the live bug: 1.9 has gl:genericRelations but the sphere
+ * renders nothing because conceptGenericRelations is empty.
+ */
+describe('1.9 live pipeline — generic projection through model-bridge', () => {
+  const URN = 'urn:oiml:pub:v:2:2012';
+  const manifest: Manifest = makeManifest({
+    id: 'vim-2012',
+    datasetUri: URN,
+    uriBase: 'https://oimlsmart.github.io/vocab',
+  });
+  const noEdges: GraphEdge[] = [];
+  const noopRouter = { push() {} } as unknown as Router;
+
+  let store: ReturnType<typeof useVocabularyStore>;
+
+  beforeEach(() => {
+    setupPinia();
+    resetFactory();
+    store = useVocabularyStore();
+    store.manifests.set(manifest.id, manifest);
+
+    const factory = getFactory();
+    factory.resolveRelatedRef = vi.fn((ref: { source: string | null; id: string | null } | null) =>
+      ref?.source === URN && ref.id
+        ? { registerId: manifest.id, conceptId: ref.id }
+        : null,
+    );
+  });
+
+  it('projects gl:genericRelations → conceptGenericRelations through conceptFromJson', () => {
+    const liveJson = {
+      '@context': 'https://glossarist.org/ns/context.jsonld',
+      '@id': 'https://oimlsmart.github.io/vocab/vim-2012/concept/1.9',
+      '@type': 'gl:Concept',
+      'gl:identifier': '1.9',
+      'gl:status': 'valid',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:entryStatus': 'valid',
+          'gl:designation': [{ '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'measurement unit' }],
+          'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'real scalar quantity' }],
+        },
+      },
+      'gl:related': [
+        { '@type': 'gl:RelatedConcept', 'gl:relationshipType': 'broader_generic',
+          'gl:ref': { '@type': 'gl:ConceptRef', 'gl:source': URN, 'gl:id': '1.12' } },
+      ],
+      'gl:genericRelations': [
+        {
+          '@type': 'gl:GenericRelation',
+          'gl:comprehensive': { '@type': 'gl:ConceptRef', 'gl:source': URN, 'gl:id': '1.9' },
+          'gl:criterion': { eng: 'by magnitude relationship to a reference measurement unit' },
+          'gl:hasGeneric': [
+            { '@type': 'gl:GenericMember',
+              'gl:ref': { '@type': 'gl:ConceptRef', 'gl:source': URN, 'gl:id': '1.17' },
+              'gl:presence': 'required', 'gl:count': 'at_least_one',
+              'gl:delimitingCharacteristic': { eng: 'multiple of a unit' } },
+            { '@type': 'gl:GenericMember',
+              'gl:ref': { '@type': 'gl:ConceptRef', 'gl:source': URN, 'gl:id': '1.18' },
+              'gl:presence': 'required', 'gl:count': 'at_least_one',
+              'gl:delimitingCharacteristic': { eng: 'submultiple of a unit' } },
+            { '@type': 'gl:GenericMember',
+              'gl:ref': { '@type': 'gl:ConceptRef', 'gl:source': URN, 'gl:id': '1.12' },
+              'gl:presence': 'required', 'gl:count': 'at_least_one',
+              'gl:delimitingCharacteristic': { eng: 'coherent derived unit' } },
+          ],
+          'gl:completeness': 'partial',
+        },
+      ],
+    };
+
+    const concept = conceptFromJson(liveJson as any);
+
+    /* Sanity: model-bridge produced a Concept with relations. */
+    expect(concept).toBeTruthy();
+
+    /* Project through useConceptEdges, exactly as ConceptView does. */
+    const { conceptGenericRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'vim-2012'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+
+    const rels = conceptGenericRelations.value;
+    /* This is the live-bug assertion: must NOT be empty. */
+    expect(rels).toHaveLength(1);
+    expect(rels[0].members).toHaveLength(3);
+    expect(rels[0].members.map(m => m.uri)).toEqual([
+      'https://oimlsmart.github.io/vocab/vim-2012/concept/1.17',
+      'https://oimlsmart.github.io/vocab/vim-2012/concept/1.18',
+      'https://oimlsmart.github.io/vocab/vim-2012/concept/1.12',
+    ]);
+  });
+});

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/adapters/model-bridge/jsonld-types.ts

@@ -141,6 +141,8 @@ export interface JsonLdPartitiveMember {
   'gl:count'?: string;
   /** ISO 704:2022: delimiting part (3× stroke width in diagrams) */
   'gl:isDelimiting'?: boolean;
+  /** ISO 704:2022 §5.5.4.2.1: GenericMember delimiting characteristic (required on generic members) */
+  'gl:delimitingCharacteristic'?: Record<string, string> | string;
   /** Legacy v3 field — one-string multiplicity, split into presence+count */
   'gl:multiplicity'?: string;
   /** Legacy v2 field — migrated to presence+count */

package/src/adapters/model-bridge.ts

@@ -516,6 +516,59 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
   return out;
 }
 
+/**
+ * Map a GenericRelation JSON-LD entry to the dict shape that
+ * glossarist-js's GenericHyperedge constructor expects.
+ *
+ * Mirrors mapPartitiveRelationFromJsonLd but reads `gl:hasGeneric` and
+ * carries each member's `gl:delimitingCharacteristic` (ISO 704:2022
+ * §5.5.4.2.1 — required on every GenericMember).
+ */
+function mapGenericRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<string, unknown> | null {
+  const comprehensive = r[GL.COMPREHENSIVE] ? mapRefFromJsonLd(r[GL.COMPREHENSIVE]) : null;
+  if (!comprehensive) return null;
+
+  const members = (r[GL.HAS_GENERIC] ?? [])
+    .map((m): Record<string, unknown> | null => {
+      const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
+      if (!ref) return null;
+      const out: Record<string, unknown> = { ref };
+      const presence = m[GL.PRESENCE];
+      const count = m[GL.COUNT];
+      if (isPartitivePresence(presence) && isPartitiveCount(count)) {
+        out.presence = presence;
+        out.count = count;
+      } else {
+        const raw = m[GL.MULTIPLICITY] ?? splitLegacyCertainty(m[GL.CERTAINTY]);
+        if (raw) {
+          const parts = splitMultiplicity(raw);
+          out.presence = parts.presence;
+          out.count = parts.count;
+        }
+      }
+      const dc = m[GL.DELIMITING_CHARACTERISTIC];
+      if (dc) {
+        out.delimitingCharacteristic = typeof dc === 'string' ? { default: dc } : dc;
+      }
+      return out;
+    })
+    .filter((m): m is Record<string, unknown> => m !== null);
+
+  if (members.length < 2) return null;
+
+  const out: Record<string, unknown> = { comprehensive, members };
+
+  if (r[GL.COMPLETENESS]) out.completeness = r[GL.COMPLETENESS];
+
+  if (r[GL.CRITERION]) {
+    out.criterion = typeof r[GL.CRITERION] === 'string'
+      ? { default: r[GL.CRITERION] }
+      : r[GL.CRITERION];
+  }
+
+  return out;
+}
+
 /** Migrate legacy v2 certainty → old v3 multiplicity string. */
 function splitLegacyCertainty(certainty: string | undefined): string | null {
   if (!certainty) return null;
@@ -549,6 +602,9 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const partitiveRelations = (doc[GL.PARTITIVE_RELATIONS] ?? [])
     .map(mapPartitiveRelationFromJsonLd)
     .filter((r): r is Record<string, unknown> => r !== null);
+  const genericRelations = (doc[GL.GENERIC_RELATIONS] ?? [])
+    .map(mapGenericRelationFromJsonLd)
+    .filter((r): r is Record<string, unknown> => r !== null);
   const tagsArr = doc[GL.TAGS];
   const tags = Array.isArray(tagsArr) ? [...tagsArr] : [];
 
@@ -559,6 +615,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     localizations,
     related,
     partitive_relations: partitiveRelations,
+    generic_relations: genericRelations,
     tags,
     figures: normalizeEntityRefs(doc[GL.FIGURE_REF]),
     tables: normalizeEntityRefs(doc[GL.TABLE_REF]),

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;
@@ -1050,7 +1078,7 @@ const legendItems = computed(() => {
   if (partitiveCount > 0) {
     typeMap.set('__partitive__', {
       type: '__partitive__',
-      label: 'partitive relation',
+      label: 'Partitive Relation',
       color: uiStore.isDark ? '#2dd4bf' : '#0d9488',
       count: partitiveCount,
     });
@@ -1060,7 +1088,7 @@ const legendItems = computed(() => {
   if (genericCount > 0) {
     typeMap.set('__generic__', {
       type: '__generic__',
-      label: 'generic relation',
+      label: 'General Relation',
       color: uiStore.isDark ? '#fbbf24' : '#b45309',
       count: genericCount,
     });

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;
 }
 
+