@glossarist/concept-browser 0.7.96 → 0.7.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.96",
+  "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/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

@@ -1078,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,
     });
@@ -1088,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,
     });