@glossarist/concept-browser 0.7.93 → 0.7.94

package/package.json

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

package/src/__tests__/__fixtures__/concepts.ts

@@ -204,6 +204,35 @@ function withdrawnConcept(): Concept {
   });
 }
 
+function withPartitiveHyperedge(): Concept {
+  const source = 'urn:glossarist:fixtures';
+  return Concept.fromJSON({
+    id: '1.3',
+    uri: `${BASE}/with-partitive-hyperedge`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'system of quantities', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that has a partitive decomposition.' }],
+      },
+    },
+    relations: [
+      {
+        type: 'partitive_relation',
+        comprehensive: { source, id: '1.3' },
+        members: [
+          { ref: { source, id: '1.22' }, presence: 'required', count: 'at_least_one' },
+          { ref: { source, id: '1.4' },  presence: 'required', count: 'multiple' },
+          { ref: { source, id: '1.5' },  presence: 'required', count: 'at_least_one' },
+        ],
+        completeness: 'complete',
+      },
+    ],
+  });
+}
+
 export const CONCEPT_FIXTURES: readonly ConceptFixture[] = [
   { name: 'minimal',            description: 'one localization, one designation',                uri: `${BASE}/minimal`,            concept: minimal() },
   { name: 'multilingual',       description: 'three languages across Latn and CJK scripts',      uri: `${BASE}/multilingual`,       concept: multilingual() },
@@ -212,6 +241,7 @@ export const CONCEPT_FIXTURES: readonly ConceptFixture[] = [
   { name: 'with-non-verbal',    description: 'figure, formula, and table non-verbal reps',       uri: `${BASE}/with-non-verbal`,    concept: withNonVerbal() },
   { name: 'with-dates',         description: 'accepted/amended/retired lifecycle',               uri: `${BASE}/with-dates`,         concept: withDates() },
   { name: 'withdrawn',          description: 'withdrawn status with retirement date (J3)',        uri: `${BASE}/withdrawn`,          concept: withdrawnConcept() },
+  { name: 'with-partitive-hyperedge', description: 'partitive decomposition in concept.relations', uri: `${BASE}/with-partitive-hyperedge`, concept: withPartitiveHyperedge() },
 ];
 
 export function fixtureByName(name: string): ConceptFixture {

package/src/__tests__/composables/use-concept-edges-hyperedge.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { computed, ref } from 'vue';
+import type { Router } from 'vue-router';
+import { useConceptEdges } from '../../composables/use-concept-edges';
+import { useVocabularyStore } from '../../stores/vocabulary';
+import type { Manifest, GraphEdge } from '../../adapters/types';
+import { makeManifest, setupPinia } from '../test-helpers';
+import { fixtureByName } from '../__fixtures__/concepts';
+import { getFactory, resetFactory } from '../../adapters/factory';
+
+/**
+ * Regression test for the sphere-view hyperedge projection.
+ *
+ * Bug (2026-07-30): ConceptView.vue read `concept.partitiveRelations`
+ * — a field glossarist 0.4.34 REMOVED. The field was silently
+ * `undefined`, the sphere rendered no rake, and no test caught it.
+ *
+ * Fix: ConceptView consumes `useConceptEdges.conceptPartitiveRelations`,
+ * which reads the unified `concept.relations` array and filters by
+ * `instanceof PartitiveHyperedge`. This spec pins that contract —
+ * if glossarist ever renames or removes `.relations`, this fails.
+ */
+describe('useConceptEdges — hyperedge projection (regression)', () => {
+  const URN_SOURCE = 'urn:glossarist:fixtures';
+  const manifest: Manifest = makeManifest({
+    id: 'fixtures',
+    datasetUri: URN_SOURCE,
+    uriBase: 'https://glossarist.org',
+  });
+  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_SOURCE && ref.id
+        ? { registerId: manifest.id, conceptId: ref.id }
+        : null,
+    );
+  });
+
+  it('projects a PartitiveHyperedge from concept.relations', () => {
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+
+    const rels = conceptPartitiveRelations.value;
+    expect(rels).toHaveLength(1);
+
+    const [rel] = rels;
+    expect(rel.comprehensive).toBe('https://glossarist.org/fixtures/concept/1.3');
+    expect(rel.partitives).toHaveLength(3);
+    expect(rel.partitives.map(m => m.uri)).toEqual([
+      'https://glossarist.org/fixtures/concept/1.22',
+      'https://glossarist.org/fixtures/concept/1.4',
+      'https://glossarist.org/fixtures/concept/1.5',
+    ]);
+    expect(rel.partitives[1].presence).toBe('required');
+    expect(rel.partitives[1].count).toBe('multiple');
+  });
+
+  it('returns [] when concept is null (loading state)', () => {
+    const { conceptPartitiveRelations, conceptGenericRelations } = useConceptEdges(
+      computed(() => null),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value).toEqual([]);
+    expect(conceptGenericRelations.value).toEqual([]);
+  });
+
+  it('returns [] when manifest is null', () => {
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => null),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value).toEqual([]);
+  });
+
+  it('would have caught the .partitiveRelations regression', () => {
+    // Simulate the pre-fix behavior: the old code read concept.partitiveRelations
+    // (undefined in glossarist 0.4.34+) and produced an empty array.
+    // This spec proves the projection now reads concept.relations instead.
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    expect((concept as any).partitiveRelations).toBeUndefined();
+    expect((concept as any).relations).toHaveLength(1);
+
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value.length).toBe(1);
+  });
+});

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -39,7 +39,7 @@ function makePartitive(
   if (fields.presence) data.presence = fields.presence;
   if (fields.count) data.count = fields.count;
   if (fields.isDelimiting) data.is_delimiting = fields.isDelimiting;
-  return new PartitiveMemberModel(data as any) as PartitiveMember;
+  return new (PartitiveMemberModel as unknown as new (data: unknown) => PartitiveMember)(data) as PartitiveMember;
 }
 
 function makeRelation(opts: {
@@ -48,7 +48,7 @@ function makeRelation(opts: {
   completeness?: 'complete' | 'partial';
   criterion?: Record<string, string>;
 }): PartitiveHyperedge {
-  return new PartitiveHyperedgeModel(opts as any) as PartitiveHyperedge;
+  return new (PartitiveHyperedgeModel as unknown as new (data: unknown) => PartitiveHyperedge)(opts) as PartitiveHyperedge;
 }
 
 describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {

package/src/adapters/non-verbal/glossarist-augment.d.ts

@@ -171,8 +171,6 @@ declare module 'glossarist' {
 
   interface Concept {
     readonly relations: AbstractHyperedge[];
-    readonly partitiveRelations: PartitiveHyperedge[];
-    readonly genericRelations: GenericHyperedge[];
   }
 
   // Re-exposed here so callers importing from the top-level `glossarist`

package/src/components/ConceptRdfView.vue

@@ -10,12 +10,14 @@ import { useRdfDocument } from './use-rdf-document';
 const props = defineProps<{
   concept: Concept;
   registerId: string;
-  conceptUriValue: string;
+  conceptUriValue: string | null;
 }>();
 
+const uri = computed(() => props.conceptUriValue ?? '');
+
 const { sections, turtle, jsonld, typeChain } = useRdfDocument(
   () => props.concept,
-  () => props.conceptUriValue,
+  () => uri.value,
 );
 
 const resourceCount = computed(() => sections.value.length);
@@ -23,11 +25,11 @@ const conceptId = computed(() => props.concept.id);
 </script>
 
 <template>
-  <ErrorBoundary title="RDF view failed" :retry-key="conceptUriValue">
+  <ErrorBoundary title="RDF view failed" :retry-key="uri">
     <div class="space-y-6">
       <div class="card p-5">
         <div class="flex items-start justify-between gap-3">
-          <RdfInstanceHeader :uri="conceptUriValue" :concept-id="conceptId" />
+          <RdfInstanceHeader :uri="uri" :concept-id="conceptId" />
         </div>
         <div class="mt-4 pt-3 border-t border-ink-100/60">
           <div class="flex items-center gap-1.5 flex-wrap text-xs text-ink-400">

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

@@ -39,9 +39,9 @@ export interface EdgeDisplay {
 }
 
 export function useConceptEdges(
-  concept: ComputedRef<Concept>,
+  concept: ComputedRef<Concept | null | undefined>,
   registerId: ComputedRef<string>,
-  manifest: ComputedRef<Manifest>,
+  manifest: ComputedRef<Manifest | null | undefined>,
   edges: ComputedRef<GraphEdge[]>,
   router: Router,
 ) {
@@ -50,24 +50,30 @@ export function useConceptEdges(
   const { getColor } = useDsStyle();
   const { locale } = useI18n();
 
-  const conceptUriValue = computed(() =>
-    conceptUri(concept.value, registerId.value, manifest.value.uriBase)
-  );
+  const conceptUriValue = computed(() => {
+    if (!concept.value || !manifest.value) return null;
+    return conceptUri(concept.value, registerId.value, manifest.value.uriBase);
+  });
 
-  const outgoingEdges = computed(() =>
-    store.graph.getUniqueEdges(conceptUriValue.value, 'outgoing', 'target')
-      .filter(e => e.type !== 'domain' && e.type !== 'section')
-  );
+  const outgoingEdges = computed(() => {
+    const uri = conceptUriValue.value;
+    if (!uri) return [];
+    return store.graph.getUniqueEdges(uri, 'outgoing', 'target')
+      .filter(e => e.type !== 'domain' && e.type !== 'section');
+  });
 
-  const incomingEdges = computed(() =>
-    store.graph.getUniqueEdges(conceptUriValue.value, 'incoming', 'source')
-      .filter(e => e.type !== 'domain' && e.type !== 'section')
-  );
+  const incomingEdges = computed(() => {
+    const uri = conceptUriValue.value;
+    if (!uri) return [];
+    return store.graph.getUniqueEdges(uri, 'incoming', 'source')
+      .filter(e => e.type !== 'domain' && e.type !== 'section');
+  });
 
   const edgeDisplayCache = computed(() => {
     const cache = new Map<string, EdgeDisplay>();
+    const focusUri = conceptUriValue.value;
     for (const e of edges.value) {
-      const uri = e.source === conceptUriValue.value ? e.target : e.source;
+      const uri = e.source === focusUri ? e.target : e.source;
       if (cache.has(uri)) continue;
       const resolution = factory.resolve(uri, registerId.value);
       const isLocal = resolution.type === 'internal' && resolution.registerId === registerId.value;
@@ -131,6 +137,7 @@ export function useConceptEdges(
 
   // Concept-level related concepts (managed concept cross-references)
   const conceptRelated = computed(() => {
+    if (!concept.value) return [];
     const direct = concept.value.relatedConcepts?.filter(rc => !INVERSE_RELATIONSHIPS[rc.type]) ?? [];
     const derived = incomingEdges.value
       .filter(e => INVERSE_RELATIONSHIPS[e.type])
@@ -169,6 +176,7 @@ export function useConceptEdges(
   // discrimination is via instanceof.
   function projectHyperedge(rel: any): PartitiveRelationWire | GenericRelationWire | null {
     const source = conceptUriValue.value;
+    if (!source) return null;
     const comprehensive = resolveConceptRefUri(rel.comprehensive);
     if (!comprehensive) return null;
     const isGeneric = rel instanceof GenericHyperedge;
@@ -202,14 +210,16 @@ export function useConceptEdges(
   }
 
   const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
-    return (concept.value.relations as any[] ?? [])
+    if (!concept.value) return [];
+    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[] ?? [])
+    if (!concept.value) return [];
+    return ((concept.value.relations as any[]) ?? [])
       .filter(r => r instanceof GenericHyperedge)
       .map(projectHyperedge)
       .filter((r): r is GenericRelationWire => r !== null);

package/src/views/ConceptView.vue

@@ -2,14 +2,10 @@
 import { computed, watch, ref, onMounted, onUnmounted } from 'vue';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
-import { conceptUri } from '../adapters/model-bridge';
-import { UriRouter } from '../adapters/UriRouter';
-import type { PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
-import type { PartitiveMember } from 'glossarist/models';
-import type { PartitivePresence, PartitiveCount } from '../utils/partitive-multiplicity';
 import ConceptDetail from '../components/ConceptDetail.vue';
 import RelationSphere from '../components/RelationSphere.vue';
 import ShortcutsModal from '../components/ShortcutsModal.vue';
+import { useConceptEdges } from '../composables/use-concept-edges';
 import { useI18n } from '../i18n';
 
 const { t } = useI18n();
@@ -63,47 +59,13 @@ const edges = computed(() => store.conceptEdges);
 const activeRegisterId = computed(() => sphereFocusPayload.value?.registerId ?? props.registerId);
 const adjacent = ref({ prev: null as string | null, next: null as string | null });
 
-/**
- * Project concept.partitiveRelations (glossarist-js v2 model) into the
- * URI-resolved wire shape the sphere consumes. Mirrors the projection
- * in use-concept-edges.ts but inline here so the sphere can render rake
- * bundles without a full composable setup.
- */
-const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
-  const c = concept.value;
-  const m = manifest.value;
-  if (!c || !m) return [];
-  const sourceUri = conceptUri(c, activeRegisterId.value, m.uriBase);
-  const out: PartitiveRelationWire[] = [];
-  for (const rel of c.partitiveRelations ?? []) {
-    const compRef = rel.comprehensive;
-    const compTarget = store.manifests.get(activeRegisterId.value)
-      ? UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, compRef.id ?? '')
-      : null;
-    if (!compRef.id || !compTarget) continue;
-    const partitives: PartitiveMemberWire[] = rel.partitives
-      .map((member): PartitiveMemberWire | null => {
-        const ref = member.ref;
-        if (!ref?.id) return null;
-        const uri = UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, ref.id);
-        if (uri === sourceUri) return null;
-        const presence: PartitivePresence = member.presence;
-        const count: PartitiveCount = member.count;
-        const isDelimiting = (member as any).is_delimiting === true;
-        return { uri, presence, count, isDelimiting };
-      })
-      .filter((x): x is PartitiveMemberWire => x !== null);
-    if (partitives.length === 0) continue;
-    out.push({
-      source: sourceUri,
-      comprehensive: compTarget,
-      partitives,
-      completeness: rel.completeness,
-      register: activeRegisterId.value,
-    });
-  }
-  return out;
-});
+const { conceptPartitiveRelations } = useConceptEdges(
+  concept,
+  activeRegisterId,
+  manifest,
+  edges,
+  router,
+);
 const viewMode = ref<'detail' | 'sphere'>(
   router.currentRoute.value.query.view === 'sphere' ? 'sphere' : 'detail'
 );
@@ -326,7 +288,7 @@ onUnmounted(() => window.removeEventListener('keydown', onKeydown));
           :manifest="manifest"
           :register-id="activeRegisterId"
           :edges="edges"
-          :partitive-relations="partitiveRelationsForSphere"
+          :partitive-relations="conceptPartitiveRelations"
           @navigate="onSphereNavigate"
         />
         <!-- Detail mode -->