@glossarist/concept-browser 0.7.90 → 0.7.92

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

@@ -170,12 +170,14 @@ declare module 'glossarist' {
   function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
 
   interface Concept {
-    readonly partitiveRelations: PartitiveRelation[];
+    readonly relations: AbstractHyperedge[];
+    readonly partitiveRelations: PartitiveHyperedge[];
+    readonly genericRelations: GenericHyperedge[];
   }
 
   // Re-exposed here so callers importing from the top-level `glossarist`
   // entry get the MECE-augmented shape, not the stale d.ts type.
-  export class PartitiveMember extends GlossaristModel {
+  export class HyperedgeMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
       presence?: PartitivePresence;
@@ -189,36 +191,43 @@ declare module 'glossarist' {
     readonly isRequired: boolean;
     readonly isOptional: boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
-    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): HyperedgeMember;
     static identityOf(value: unknown): string;
   }
 
-  export class PartitiveRelation extends GlossaristModel {
-    constructor(data?: {
-      comprehensive?: ConceptRef;
-      partitives?: PartitiveMember[];
-      completeness?: Completeness;
-      criterion?: Record<string, string> | string;
-    });
+  export class PartitiveMember extends HyperedgeMember {}
+  export class GenericMember extends HyperedgeMember {}
+
+  export class AbstractHyperedge extends GlossaristModel {
     readonly comprehensive: ConceptRef;
-    readonly partitives: PartitiveMember[];
+    readonly members: HyperedgeMember[];
     readonly completeness: Completeness;
     readonly criterion: Record<string, string> | null;
+    readonly sources: ConceptSource[];
+    readonly notes: Record<string, string> | null;
+    readonly status: string | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
     readonly isCoordinate: boolean;
-    hasPlurality(): boolean;
-    hasCriterion(): boolean;
-    toJSON(): {
-      comprehensive: ReturnType<ConceptRef['toJSON']>;
-      partitives: ReturnType<PartitiveMember['toJSON']>[];
-      completeness: Completeness;
-      criterion?: Record<string, string>;
-    };
-    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class PartitiveHyperedge extends AbstractHyperedge {
+    get partitives(): HyperedgeMember[];
+    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
     static identityOf(value: unknown): string;
   }
+
+  export class GenericHyperedge extends AbstractHyperedge {
+    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  // Legacy aliases (deprecated — use Hyperedge-based names)
+  export class PartitiveRelation extends PartitiveHyperedge {}
 }
 
 // Re-declare the same exports under the 'glossarist/models' subpath so
@@ -261,9 +270,9 @@ declare module 'glossarist/models' {
   // (TypeSharedPlurality removed — superseded by presence/count on
   // PartitiveMember per MECE refactor. Was dead code.)
 
-  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
+  // ── Hyperedge classes (glossarist 0.4.33 — unified n-ary model) ─
 
-  export class PartitiveMember extends GlossaristModel {
+  export class HyperedgeMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
       presence?: PartitivePresence;
@@ -274,37 +283,44 @@ declare module 'glossarist/models' {
     readonly presence: PartitivePresence;
     readonly count: PartitiveCount;
     readonly is_delimiting: boolean;
-    readonly isRequired: boolean;
-    readonly isOptional: boolean;
+    required(): boolean;
+    optional(): boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
-    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): HyperedgeMember;
     static identityOf(value: unknown): string;
   }
 
-  export class PartitiveRelation extends GlossaristModel {
-    constructor(data?: {
-      comprehensive?: ConceptRef;
-      partitives?: PartitiveMember[];
-      completeness?: Completeness;
-      criterion?: Record<string, string> | string;
-    });
+  export class PartitiveMember extends HyperedgeMember {}
+  export class GenericMember extends HyperedgeMember {}
+
+  export class AbstractHyperedge extends GlossaristModel {
     readonly comprehensive: ConceptRef;
-    readonly partitives: PartitiveMember[];
+    readonly members: HyperedgeMember[];
     readonly completeness: Completeness;
     readonly criterion: Record<string, string> | null;
+    readonly sources: ConceptSource[];
+    readonly notes: Record<string, string> | null;
+    readonly status: string | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
     readonly isCoordinate: boolean;
-    hasPlurality(): boolean;
-    hasCriterion(): boolean;
-    toJSON(): {
-      comprehensive: ReturnType<ConceptRef['toJSON']>;
-      partitives: ReturnType<PartitiveMember['toJSON']>[];
-      completeness: Completeness;
-      criterion?: Record<string, string>;
-    };
-    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class PartitiveHyperedge extends AbstractHyperedge {
+    get partitives(): HyperedgeMember[];
+    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class GenericHyperedge extends AbstractHyperedge {
+    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
     static identityOf(value: unknown): string;
   }
+
+  // Legacy aliases (deprecated)
+  export class PartitiveRelation extends PartitiveHyperedge {}
 }

package/src/adapters/types.ts

@@ -179,6 +179,30 @@ export interface PartitiveMemberWire {
   isDelimiting: boolean;
 }
 
+/**
+ * GenericRelationWire — ISO 704 / 1087-1 / 12620 generic (genus/
+ * species) decomposition, mirror of PartitiveRelationWire.
+ *
+ * The OIML V 2-200:2010 dataset has ~8 generic hyperedges with
+ * multiple criterion groups per comprehensive; this shape supports
+ * that natively. See docs/design/generic-relation.md (concept-model).
+ */
+export interface GenericRelationWire {
+  source: string;
+  comprehensive: string;
+  members: GenericMemberWire[];
+  completeness: 'complete' | 'partial';
+  criterion?: Record<string, string>;
+  register: string;
+}
+
+export interface GenericMemberWire {
+  uri: string;
+  presence: 'required' | 'optional';
+  count: 'exactly_one' | 'at_least_one' | 'multiple';
+  isDelimiting: boolean;
+}
+
 export interface GraphNode {
   uri: string;
   register: string;

package/src/adapters/wire-keys.ts

@@ -37,6 +37,7 @@ export const GL = {
   LOCALIZED_CONCEPT: 'gl:localizedConcept',
   RELATED: 'gl:related',
   PARTITIVE_RELATIONS: 'gl:partitiveRelations',
+  GENERIC_RELATIONS: 'gl:genericRelations',
   TAGS: 'gl:tags',
 
   // LocalizedConcept
@@ -139,6 +140,8 @@ export const GL = {
   // PartitiveRelation
   COMPREHENSIVE: 'gl:comprehensive',
   HAS_PARTITIVE: 'gl:hasPartitive',
+  HAS_GENERIC: 'gl:hasGeneric',
+  HAS_MEMBER: 'gl:members',
   COMPLETENESS: 'gl:completeness',
   CRITERION: 'gl:criterion',
 

package/src/components/ConceptDetail.vue

@@ -28,6 +28,7 @@ import ConceptEditionRail from './ConceptEditionRail.vue';
 import NonVerbalRepDisplay from './NonVerbalRepDisplay.vue';
 import NonVerbalList from './non-verbal/NonVerbalList.vue';
 import PartitiveRelationList from './PartitiveRelationList.vue';
+import GenericRelationList from './GenericRelationList.vue';
 import ConceptDiffModal from './ConceptDiffModal.vue';
 import CitationDisplay from './CitationDisplay.vue';
 import DesignationList from './DesignationList.vue';
@@ -75,6 +76,7 @@ const {
   inverseEdgeType,
   conceptRelated,
   conceptPartitiveRelations,
+  conceptGenericRelations,
   getResolvedRef,
   relatedLabel,
   navigateEdge,
@@ -577,6 +579,14 @@ const nonVerbalReps = computed(() => {
             :register-id="registerId"
           />
 
+          <!-- Generic relations — genus/species decompositions (ISO 704) -->
+          <GenericRelationList
+            v-if="conceptGenericRelations.length"
+            :relations="conceptGenericRelations"
+            :manifest="manifest"
+            :register-id="registerId"
+          />
+
           <!-- Edition series — supersession chain across vocabulary editions -->
           <ConceptEditionRail
             :concept-uri="conceptUri(props.concept, props.registerId, props.manifest.uriBase)"

package/src/components/GenericRelationList.vue

@@ -0,0 +1,168 @@
+<script setup lang="ts">
+/**
+ * GenericRelationList — renders one-to-many generic (genus/species)
+ * decompositions as ISO 704 rake diagrams. Mirror of
+ * PartitiveRelationList with type label swapped.
+ *
+ * Each relation card shows:
+ *   - completeness badge (Complete / Partial)
+ *   - the comprehensive (genus) designation as the card title
+ *   - optional criterion as italic text
+ *   - the rake diagram itself (PartitiveRelationDiagram, reused —
+ *     the line notation is identical for generic rakes)
+ *
+ * OIML V 2-200:2010 has ~8 generic hyperedges; 5.1 measurement
+ * standard alone has 6 criterion groups. This component is the
+ * primary rendering surface for those datasets.
+ */
+import type { GenericRelationWire, Manifest } from '../adapters/types';
+import { useRouter } from 'vue-router';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { getFactory } from '../adapters/factory';
+import { useI18n, locale } from '../i18n';
+import { completenessLabel } from '../utils/partitive-relation-styling';
+import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
+import { resolveDesignation } from '../utils/resolve-designation';
+import PartitiveRelationDiagram, {
+  type PartitiveMemberLabeled,
+} from './PartitiveRelationDiagram.vue';
+
+const props = defineProps<{
+  relations: GenericRelationWire[];
+  manifest: Manifest;
+  registerId: string;
+}>();
+
+const router = useRouter();
+const store = useVocabularyStore();
+const factory = getFactory();
+const { t } = useI18n();
+
+function designationFor(uri: string): string {
+  return resolveDesignation(uri, store, factory, locale.value);
+}
+
+function memberLabel(member: GenericRelationWire['members'][number]): PartitiveMemberLabeled {
+  return {
+    uri: member.uri,
+    presence: member.presence,
+    count: member.count,
+    isDelimiting: member.isDelimiting,
+    label: designationFor(member.uri),
+  };
+}
+</script>
+
+<template>
+  <section class="generic-relations" aria-label="Generic relations">
+    <div
+      v-for="(rel, i) in relations"
+      :key="`generic-${i}-${rel.comprehensive}`"
+      class="generic-relation-card"
+    >
+      <header class="relation-header">
+        <span class="badge badge-completeness" :class="`completeness-${rel.completeness}`">
+          {{ completenessLabel(rel.completeness) }}
+        </span>
+        <span class="badge badge-type">{{ t('relations.generic') }}</span>
+        <h4 class="comprehensive">{{ designationFor(rel.comprehensive) }}</h4>
+      </header>
+
+      <p v-if="rel.criterion" class="criterion">
+        <em>{{ rel.criterion[locale] || rel.criterion.eng || Object.values(rel.criterion)[0] }}</em>
+      </p>
+
+      <PartitiveRelationDiagram
+        :partitives="rel.members.map(memberLabel)"
+        :comprehensive-label="designationFor(rel.comprehensive)"
+        :completeness="rel.completeness"
+      />
+
+      <ul class="member-presence-list" aria-label="Member presence and count">
+        <li v-for="(m, j) in rel.members" :key="j">
+          <span class="member-label">{{ designationFor(m.uri) }}</span>
+          <span v-if="m.presence && m.presence !== 'required'" class="member-presence">{{ presenceLabel(m.presence) }}</span>
+          <span v-if="m.count && m.count !== 'exactly_one'" class="member-count">{{ countLabel(m.count) }}</span>
+          <span v-if="m.isDelimiting" class="member-delimiting">{{ t('relations.delimiting') }}</span>
+        </li>
+      </ul>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.generic-relation-card {
+  border: 1px solid var(--color-border, #ccc);
+  border-radius: 6px;
+  padding: 1rem;
+  margin-bottom: 1rem;
+  background: var(--color-surface, #fff);
+}
+
+.relation-header {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+
+.badge {
+  font-size: 0.75rem;
+  font-weight: 600;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.badge-completeness.completeness-complete {
+  background: var(--color-success-soft, #d4edda);
+  color: var(--color-success-fg, #155724);
+}
+
+.badge-completeness.completeness-partial {
+  background: var(--color-warn-soft, #fff3cd);
+  color: var(--color-warn-fg, #856404);
+}
+
+.badge-type {
+  background: var(--color-accent-soft, #d1ecf1);
+  color: var(--color-accent-fg, #0c5460);
+}
+
+.comprehensive {
+  margin: 0;
+  font-size: 1.1rem;
+  flex: 1 1 auto;
+}
+
+.criterion {
+  color: var(--color-text-muted, #6c757d);
+  margin: 0.5rem 0;
+  font-size: 0.95rem;
+}
+
+.member-presence-list {
+  list-style: none;
+  padding: 0;
+  margin: 0.5rem 0 0;
+  font-size: 0.85rem;
+}
+
+.member-presence-list li {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+  padding: 0.15rem 0;
+}
+
+.member-presence-list .member-presence,
+.member-presence-list .member-count,
+.member-presence-list .member-delimiting {
+  color: var(--color-text-muted, #6c757d);
+  font-size: 0.75rem;
+  border: 1px solid var(--color-border-light, #eee);
+  padding: 0.05rem 0.4rem;
+  border-radius: 3px;
+}
+</style>

package/src/components/PartitiveRelationList.vue

@@ -20,6 +20,7 @@ import { getFactory } from '../adapters/factory';
 import { useI18n, locale } from '../i18n';
 import { completenessLabel } from '../utils/partitive-relation-styling';
 import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
+import { resolveDesignation } from '../utils/resolve-designation';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from './PartitiveRelationDiagram.vue';
@@ -36,25 +37,7 @@ const factory = getFactory();
 const { t } = useI18n();
 
 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 navigate(uri: string) {