@glossarist/concept-browser 0.7.91 → 0.7.93

package/src/composables/use-concept-edges.ts

@@ -4,6 +4,8 @@ import type { Router } from 'vue-router';
 // Import the MECE-augmented types from glossarist/models (extended by
 // src/adapters/non-verbal/glossarist-augment.d.ts).
 import type { Concept, RelatedConcept, ConceptRef } from 'glossarist';
+import { PartitiveHyperedge } from 'glossarist';
+import { GenericHyperedge } from 'glossarist/models';
 import type {
   PartitiveRelation as GlsPartitiveRelation,
   PartitiveMember as GlsPartitiveMember,
@@ -13,9 +15,11 @@ import type {
   GraphEdge,
   PartitiveRelationWire,
   PartitiveMemberWire,
+  GenericRelationWire,
 } from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
+import { resolveDesignation } from '../utils/resolve-designation';
 import { UriRouter } from '../adapters/UriRouter';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
@@ -111,25 +115,7 @@ export function useConceptEdges(
    * IDs like '1.3'.
    */
   function designationFor(uri: string): string {
-    const node = store.graph.getNode(uri);
-    if (node) {
-      const des = node.designations[locale.value]
-        || node.designations.eng
-        || Object.values(node.designations)[0];
-      if (des) return des;
-    }
-    const resolution = factory.resolve(uri);
-    if (resolution.type === 'internal') {
-      const adapter = store.datasets.get(resolution.registerId);
-      const entry = adapter?.getIndexEntry(resolution.conceptId);
-      if (entry) {
-        const des = entry.designations[locale.value]
-          || entry.designations.eng
-          || Object.values(entry.designations)[0];
-        if (des) return des;
-      }
-    }
-    return resolution.type === 'internal' ? resolution.conceptId : uri;
+    return resolveDesignation(uri, store, factory, locale.value);
   }
 
   function edgeBadgeColor(type: string, direction: 'out' | 'in'): string {
@@ -174,42 +160,59 @@ export function useConceptEdges(
     });
   });
 
-  // Concept-level partitive relations (ISO 704 one-to-many decompositions).
-  // Reads the glossarist-js native model (`concept.partitiveRelations`)
-  // and projects each relation into a URI-resolved wire shape for display.
-  // Independent of binary `conceptRelated`.
-  // v2 shape per concept-model/TODO.partitive-relation-v2.
-  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
+  // Concept-level n-ary hyperedge relations (ISO 704 one-to-many
+  // decompositions). Reads the glossarist-js unified `concept.relations`
+  // array and projects PartitiveHyperedge → PartitiveRelationWire,
+  // GenericHyperedge → GenericRelationWire for display.
+  //
+  // glossarist 0.4.33+ exposes a unified `.relations` array; type
+  // discrimination is via instanceof.
+  function projectHyperedge(rel: any): PartitiveRelationWire | GenericRelationWire | null {
     const source = conceptUriValue.value;
-    const relations: readonly GlsPartitiveRelation[] = concept.value.partitiveRelations;
-    return relations
-      .map((rel): PartitiveRelationWire | null => {
-        const comprehensive = resolveConceptRefUri(rel.comprehensive);
-        if (!comprehensive) return null;
-        const partitives: PartitiveMemberWire[] = rel.partitives
-          .map((m: GlsPartitiveMember): PartitiveMemberWire | null => {
-            const uri = resolveConceptRefUri(m.ref);
-            if (!uri || uri === source) return null;
-            return {
-              uri,
-              presence: readPresence(m),
-              count: readCount(m),
-              isDelimiting: readIsDelimiting(m),
-            };
-          })
-          .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
-        if (partitives.length === 0) return null;
-
-        return {
-          source,
-          comprehensive,
-          partitives,
-          completeness: rel.completeness,
-          criterion: rel.criterion ?? undefined,
-          register: registerId.value,
+    const comprehensive = resolveConceptRefUri(rel.comprehensive);
+    if (!comprehensive) return null;
+    const isGeneric = rel instanceof GenericHyperedge;
+    const members: any[] = (rel.members ?? rel.partitives ?? [])
+      .map((m: any): any | null => {
+        const uri = resolveConceptRefUri(m.ref);
+        if (!uri || uri === source) return null;
+        const base: any = {
+          uri,
+          presence: readPresence(m),
+          count: readCount(m),
         };
+        if (isGeneric) {
+          base.delimitingCharacteristic = m.delimitingCharacteristic;
+        } else {
+          base.isDelimiting = readIsDelimiting(m);
+        }
+        return base;
       })
-      .filter((r: PartitiveRelationWire | null): r is PartitiveRelationWire => r !== null);
+      .filter((m: any | null): m is any => m !== null);
+    if (members.length === 0) return null;
+    return {
+      source,
+      comprehensive,
+      members,
+      partitives: members,
+      completeness: rel.completeness,
+      criterion: rel.criterion ?? undefined,
+      register: registerId.value,
+    };
+  }
+
+  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
+    return (concept.value.relations as any[] ?? [])
+      .filter(r => r instanceof PartitiveHyperedge)
+      .map(projectHyperedge)
+      .filter((r): r is PartitiveRelationWire => r !== null);
+  });
+
+  const conceptGenericRelations = computed<GenericRelationWire[]>(() => {
+    return (concept.value.relations as any[] ?? [])
+      .filter(r => r instanceof GenericHyperedge)
+      .map(projectHyperedge)
+      .filter((r): r is GenericRelationWire => r !== null);
   });
 
   function resolveConceptRefUri(ref: ConceptRef | null): string | null {
@@ -307,6 +310,7 @@ export function useConceptEdges(
     inverseEdgeType,
     conceptRelated,
     conceptPartitiveRelations,
+    conceptGenericRelations,
     resolveRelatedRef,
     getResolvedRef,
     relatedLabel,

package/src/utils/resolve-designation.ts

@@ -0,0 +1,50 @@
+/**
+ * Resolve a concept URI to its display designation (term string).
+ *
+ * Single SSOT for the designation fallback chain used by:
+ *   - PartitiveRelationList.vue
+ *   - GenericRelationList.vue
+ *   - use-concept-edges.ts (designationFor method)
+ *
+ * Previously each site had its own copy with subtle divergences (one
+ * used `entry.titles`, another used `entry.designations` — the former
+ * is a bug since ConceptSummary has no `titles` property).
+ *
+ * Fallback chain:
+ *   1. BFS graph node (already loaded as a neighbor) → locale → eng → any
+ *   2. Dataset adapter index entry → designations[locale] → eng → any
+ *   3. Concept ID (for internal URIs) or raw URI (for external)
+ */
+import type { useVocabularyStore } from '../stores/vocabulary';
+import type { AdapterFactory } from '../adapters/factory';
+
+type VocabularyStore = ReturnType<typeof useVocabularyStore>;
+type Factory = AdapterFactory;
+
+export function resolveDesignation(
+  uri: string,
+  store: VocabularyStore,
+  factory: Factory,
+  currentLocale: string,
+): string {
+  const node = store.graph.getNode(uri);
+  if (node) {
+    const des = node.designations[currentLocale]
+      || node.designations.eng
+      || Object.values(node.designations)[0];
+    if (des) return des;
+  }
+  const resolution = factory.resolve(uri);
+  if (resolution.type === 'internal') {
+    const adapter = store.datasets.get(resolution.registerId);
+    const entry = adapter?.getIndexEntry(resolution.conceptId);
+    if (entry) {
+      const des = entry.designations[currentLocale]
+        || entry.designations.eng
+        || Object.values(entry.designations)[0];
+      if (des) return des;
+    }
+    return resolution.conceptId;
+  }
+  return uri;
+}

package/src/views/ConceptView.vue

@@ -89,7 +89,7 @@ const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
         if (uri === sourceUri) return null;
         const presence: PartitivePresence = member.presence;
         const count: PartitiveCount = member.count;
-        const isDelimiting = member.isDelimiting;
+        const isDelimiting = (member as any).is_delimiting === true;
         return { uri, presence, count, isDelimiting };
       })
       .filter((x): x is PartitiveMemberWire => x !== null);