@glossarist/concept-browser 0.7.26 → 0.7.28

package/src/style.css

@@ -434,6 +434,14 @@
 .dark .bg-red-50 { background-color: rgba(239, 68, 68, 0.15) !important; }
 .dark .text-red-600 { color: #fca5a5 !important; }
 
+/* ── Sidebar group labels (brand colors are too dark in dark mode) ── */
+.dark .sidebar-group-label {
+  filter: brightness(2);
+}
+.dark .sidebar-group-label:hover {
+  filter: brightness(1.8);
+}
+
 /* Scrollbar hide utility */
 @layer utilities {
   .scrollbar-none { -ms-overflow-style: none; scrollbar-width: none; }

package/src/utils/concept-helpers.ts

@@ -2,30 +2,12 @@ import type { LocalizedConcept } from 'glossarist';
 import { ontology } from '../adapters/ontology-registry';
 
 export function entryStatusColor(status: string): string {
-  const colors: Record<string, string> = {
-    valid: 'badge-green',
-    not_valid: 'bg-red-50 text-red-700',
-    superseded: 'bg-red-50 text-red-700',
-    retired: 'badge-gray',
-    withdrawn: 'bg-red-100 text-red-800',
-    draft: 'badge-yellow',
-    Standard: 'badge-green',
-  };
-  return colors[status] ?? 'badge-gray';
+  return ontology.getColor('entryStatus', status) ?? 'badge-gray';
 }
 
 export function conceptStatusColor(status: string | null): string {
   if (!status) return 'badge-gray';
-  const colors: Record<string, string> = {
-    draft: 'badge-yellow',
-    submitted: 'badge-blue',
-    valid: 'badge-green',
-    not_valid: 'bg-red-50 text-red-700',
-    invalid: 'bg-red-50 text-red-700',
-    superseded: 'bg-red-50 text-red-700',
-    retired: 'badge-gray',
-  };
-  return colors[status] ?? 'badge-gray';
+  return ontology.getColor('conceptStatus', status) ?? 'badge-gray';
 }
 
 export function conceptStatusLabel(status: string | null): string {

package/src/utils/designation-registry.ts

@@ -8,45 +8,28 @@ export interface DesignationTypeInfo {
   definition?: string;
 }
 
-const TYPE_COLORS: Record<string, string> = {
-  expression: 'bg-sky-50 text-sky-700',
-  abbreviation: 'bg-amber-50 text-amber-700',
-  symbol: 'bg-violet-50 text-violet-700',
-  letter_symbol: 'bg-violet-50 text-violet-700',
-  graphical_symbol: 'bg-violet-50 text-violet-700',
-};
-
 export function designationTypeInfo(designation: Designation): DesignationTypeInfo {
   const type = designation.type;
   const concept = ontology.getConcept('designationType', type);
   return {
     label: concept?.prefLabel ?? type,
-    color: TYPE_COLORS[type] ?? 'bg-gray-50 text-gray-700',
+    color: ontology.getColor('designationType', type) ?? 'bg-gray-50 text-gray-700',
     definition: concept?.definition ?? undefined,
   };
 }
 
 export function normativeStatusInfo(status: string | null): { label: string; color: string; definition?: string } {
   if (!status) return { label: '', color: 'bg-gray-50 text-gray-700' };
-
-  const colors: Record<string, string> = {
-    preferred: 'bg-emerald-50 text-emerald-700',
-    admitted: 'bg-amber-50 text-amber-700',
-    deprecated: 'bg-red-50 text-red-700',
-    superseded: 'bg-red-50 text-red-700',
-  };
-
   const concept = ontology.getConcept('normativeStatus', status);
   return {
     label: concept?.prefLabel ?? status,
-    color: colors[status] ?? 'bg-gray-50 text-gray-700',
+    color: ontology.getColor('normativeStatus', status) ?? 'bg-gray-50 text-gray-700',
     definition: concept?.definition ?? undefined,
   };
 }
 
 export function sourceStatusInfo(status: string | null): { label: string; color: string; definition?: string } {
   if (!status) return { label: '', color: 'badge-gray' };
-
   const concept = ontology.getConcept('sourceStatus', status);
   return {
     label: concept?.prefLabel ?? status,
@@ -57,16 +40,10 @@ export function sourceStatusInfo(status: string | null): { label: string; color:
 
 export function sourceTypeInfo(type: string | null): { label: string; color: string; definition?: string } {
   if (!type) return { label: '', color: 'badge-gray' };
-
-  const colors: Record<string, string> = {
-    authoritative: 'badge-purple',
-    lineage: 'badge-blue',
-  };
-
   const concept = ontology.getConcept('sourceType', type);
   return {
     label: concept?.prefLabel ?? type,
-    color: colors[type] ?? 'badge-gray',
+    color: ontology.getColor('sourceType', type) ?? 'badge-gray',
     definition: concept?.definition ?? undefined,
   };
 }

package/src/utils/relationship-categories.ts

@@ -1,4 +1,12 @@
+/**
+ * Relationship categorization — fully derived from the ontology taxonomy.
+ *
+ * RELATIONSHIP_CATEGORIES, INVERSE_RELATIONSHIPS, and the category lookup
+ * map are all computed from `taxonomies.json` at module load time.
+ * Adding a new relationship type requires only a taxonomy edit — no code changes.
+ */
 import { ontology } from '../adapters/ontology-registry';
+import type { TaxonomyCategory } from '../adapters/ontology-registry';
 
 export interface RelationshipCategory {
   id: string;
@@ -7,125 +15,64 @@ export interface RelationshipCategory {
   color: string;
 }
 
-export const RELATIONSHIP_CATEGORIES: RelationshipCategory[] = [
-  {
-    id: 'hierarchical',
-    label: 'Hierarchy',
-    types: ['broader', 'narrower', 'broader_generic', 'narrower_generic',
-            'broader_partitive', 'narrower_partitive', 'broader_instantial', 'narrower_instantial',
-            'has_concept', 'is_concept_of', 'instance_of', 'has_instance',
-            'has_part', 'is_part_of', 'inherits', 'inherited_by'],
-    color: 'text-blue-600 bg-blue-50',
-  },
-  {
-    id: 'mapping',
-    label: 'Equivalence',
-    types: ['equivalent', 'exact_match', 'close_match', 'broad_match', 'narrow_match', 'related_match'],
-    color: 'text-emerald-600 bg-emerald-50',
-  },
-  {
-    id: 'associative',
-    label: 'Associative',
-    types: ['see', 'related_concept', 'related_concept_broader', 'related_concept_narrower', 'references'],
-    color: 'text-violet-600 bg-violet-50',
-  },
-  {
-    id: 'lifecycle',
-    label: 'Lifecycle',
-    types: ['deprecates', 'deprecated_by', 'supersedes', 'superseded_by',
-            'replaces', 'replaced_by', 'invalidates', 'invalidated_by',
-            'retires', 'retired_by'],
-    color: 'text-red-600 bg-red-50',
-  },
-  {
-    id: 'comparative',
-    label: 'Comparison',
-    types: ['compare', 'contrast'],
-    color: 'text-amber-600 bg-amber-50',
-  },
-  {
-    id: 'definitional',
-    label: 'Definitional',
-    types: ['has_definition', 'definition_of', 'has_version', 'version_of',
-            'current_version', 'current_version_of'],
-    color: 'text-cyan-600 bg-cyan-50',
-  },
-  {
-    id: 'spatiotemporal',
-    label: 'Spatiotemporal',
-    types: ['sequentially_related', 'spatially_related', 'temporally_related'],
-    color: 'text-teal-600 bg-teal-50',
-  },
-  {
-    id: 'lexical',
-    label: 'Lexical',
-    types: ['homograph', 'false_friend'],
-    color: 'text-pink-600 bg-pink-50',
-  },
-  {
-    id: 'designation',
-    label: 'Designation',
-    types: ['abbreviated_form_for', 'short_form_for'],
-    color: 'text-gray-600 bg-gray-50',
-  },
-];
-
-
-
-export const INVERSE_RELATIONSHIPS: Record<string, string> = {
-  // Lifecycle (ISO 10241-1)
-  supersedes: 'superseded_by',
-  superseded_by: 'supersedes',
-  deprecates: 'deprecated_by',
-  deprecated_by: 'deprecates',
-  replaces: 'replaced_by',
-  replaced_by: 'replaces',
-  invalidates: 'invalidated_by',
-  invalidated_by: 'invalidates',
-  retires: 'retired_by',
-  retired_by: 'retires',
-
-  // Hierarchical (generic — SKOS)
-  broader: 'narrower',
-  narrower: 'broader',
-  broader_generic: 'narrower_generic',
-  narrower_generic: 'broader_generic',
-
-  // Hierarchical (partitive — ISO 25964)
-  broader_partitive: 'narrower_partitive',
-  narrower_partitive: 'broader_partitive',
-  has_part: 'is_part_of',
-  is_part_of: 'has_part',
-
-  // Hierarchical (instantial — ISO 25964)
-  broader_instantial: 'narrower_instantial',
-  narrower_instantial: 'broader_instantial',
-  instance_of: 'has_instance',
-  has_instance: 'instance_of',
-
-  // ISO 19135 concept-to-concept
-  has_concept: 'is_concept_of',
-  is_concept_of: 'has_concept',
-  inherits: 'inherited_by',
-  inherited_by: 'inherits',
-  has_definition: 'definition_of',
-  definition_of: 'has_definition',
-
-  // ISO 19135 versioning
-  has_version: 'version_of',
-  version_of: 'has_version',
-  current_version: 'current_version_of',
-  current_version_of: 'current_version',
-
-  // Symmetric (self-inverse)
-  equivalent: 'equivalent',
-  exact_match: 'exact_match',
-  compare: 'compare',
-  contrast: 'contrast',
-  close_match: 'close_match',
-  related_match: 'related_match',
-  related_concept: 'related_concept',
-};
+// ── Derived data ──────────────────────────────────────────────────────────
+
+const CATEGORY_ORDER = [
+  'hierarchical', 'mapping', 'associative', 'lifecycle',
+  'comparative', 'definitional', 'spatiotemporal', 'lexical', 'designation',
+] as const;
+
+function buildRelationshipData() {
+  const allTypes = ontology.getAll('relationshipType');
+  const categoryTypes = new Map<string, string[]>();
+  const inverseMap: Record<string, string> = {};
+
+  for (const concept of allTypes) {
+    if (concept.inverseOf) {
+      inverseMap[concept.id] = concept.inverseOf;
+    }
+
+    if (concept.category) {
+      const list = categoryTypes.get(concept.category) ?? [];
+      list.push(concept.id);
+      categoryTypes.set(concept.category, list);
+    }
+  }
+
+  const categories: RelationshipCategory[] = [];
+  for (const catId of CATEGORY_ORDER) {
+    const types = categoryTypes.get(catId);
+    if (!types) continue;
+    const config = ontology.getCategoryConfig('relationshipType', catId);
+    categories.push({
+      id: catId,
+      label: config?.label ?? catId,
+      types,
+      color: config?.color ?? 'text-gray-600 bg-gray-50',
+    });
+  }
+
+  // Add any categories not in the canonical order
+  for (const [catId, types] of categoryTypes) {
+    if (categories.some(c => c.id === catId)) continue;
+    const config = ontology.getCategoryConfig('relationshipType', catId);
+    categories.push({
+      id: catId,
+      label: config?.label ?? catId,
+      types,
+      color: config?.color ?? 'text-gray-600 bg-gray-50',
+    });
+  }
+
+  return { categories, inverseMap };
+}
+
+const { categories: RELATIONSHIP_CATEGORIES, inverseMap: INVERSE_RELATIONSHIPS } = buildRelationshipData();
+
+export { RELATIONSHIP_CATEGORIES, INVERSE_RELATIONSHIPS };
+
+// ── Lookup maps ───────────────────────────────────────────────────────────
+
 const CATEGORY_MAP = new Map<string, RelationshipCategory>();
 for (const cat of RELATIONSHIP_CATEGORIES) {
   for (const t of cat.types) {
@@ -133,16 +80,15 @@ for (const cat of RELATIONSHIP_CATEGORIES) {
   }
 }
 
+// ── Public API ────────────────────────────────────────────────────────────
+
 export function categorizeRelationship(type: string): RelationshipCategory {
   return CATEGORY_MAP.get(type) ?? { id: 'other', label: 'Other', types: [type], color: 'text-gray-600 bg-gray-50' };
 }
 
 export function relationshipLabel(type: string): string {
-  // Check the ontology taxonomy first (for glossarist-specific types)
   const concept = ontology.getConcept('relationshipType', type);
   if (concept?.prefLabel) return concept.prefLabel;
-
-  // Fallback: humanize the type string
   return type.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
 }