@glossarist/concept-browser 0.3.7 → 0.4.0

package/scripts/generate-ontology-schema.mjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * Parse the glossarist OWL ontology (TTL) into a structured JSON schema
+ * for the Ontospy-style browser view.
+ *
+ * Reads:  ../concept-model/ontologies/glossarist.ttl
+ * Writes: src/data/ontology-schema.json
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const ONTOLOGY_TTL = resolve(ROOT, '..', 'concept-model', 'ontologies', 'glossarist.ttl');
+const OUTPUT = resolve(ROOT, 'src', 'data', 'ontology-schema.json');
+
+const KNOWN_PREFIXES = {
+  gloss: 'https://www.glossarist.org/ontologies/',
+  owl: 'http://www.w3.org/2002/07/owl#',
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  skos: 'http://www.w3.org/2004/02/skos/core#',
+  xl: 'http://www.w3.org/2008/05/skos-xl#',
+  'iso-thes': 'http://purl.org/iso25964/skos-thes#',
+  dcterms: 'http://purl.org/dc/terms/',
+  prov: 'http://www.w3.org/ns/prov#',
+  xsd: 'http://www.w3.org/2001/XMLSchema#',
+};
+
+function expandPrefixed(term) {
+  for (const [prefix, uri] of Object.entries(KNOWN_PREFIXES)) {
+    if (term.startsWith(prefix + ':')) {
+      return uri + term.slice(prefix.length + 1);
+    }
+  }
+  return term;
+}
+
+function compactIri(iri) {
+  for (const [prefix, uri] of Object.entries(KNOWN_PREFIXES)) {
+    if (iri.startsWith(uri)) {
+      return prefix + ':' + iri.slice(uri.length);
+    }
+  }
+  return iri;
+}
+
+/**
+ * Minimal TTL subject-block splitter. Handles nested [] and () and quoted strings.
+ */
+function splitSubjectBlocks(text) {
+  const blocks = [];
+  let depth = 0;
+  let start = -1;
+  let inTripleQuote = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+
+    if (inTripleQuote) {
+      if (ch === '"' && text.slice(i, i + 3) === '"""') {
+        inTripleQuote = false;
+        i += 2;
+      }
+      continue;
+    }
+
+    if (ch === '"' && text.slice(i, i + 3) === '"""') {
+      inTripleQuote = true;
+      i += 2;
+      continue;
+    }
+
+    if (ch === '"') {
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === '\\') i++;
+        i++;
+      }
+      continue;
+    }
+
+    if (ch === '[' || ch === '(') depth++;
+    if (ch === ']' || ch === ')') depth--;
+
+    if (depth === 0 && ch === '.') {
+      if (start >= 0) {
+        blocks.push(text.slice(start, i));
+        start = -1;
+      }
+    } else if (start < 0 && /\S/.test(ch)) {
+      start = i;
+    }
+  }
+
+  return blocks;
+}
+
+function extractLiteral(block, predicate) {
+  const tripleQuoted = new RegExp(predicate + '\\s+"""([^]*?)"""@en');
+  let m = block.match(tripleQuoted);
+  if (m) return m[1].replace(/\s+/g, ' ').trim();
+
+  const singleQuoted = new RegExp(predicate + '\\s+"([^"]*?)"@en');
+  m = block.match(singleQuoted);
+  if (m) return m[1];
+
+  // Without @en
+  const plain = new RegExp(predicate + '\\s+"""([^]*?)"""');
+  m = block.match(plain);
+  if (m) return m[1].replace(/\s+/g, ' ').trim();
+
+  const plainSingle = new RegExp(predicate + '\\s+"([^"]*?)"');
+  m = block.match(plainSingle);
+  return m ? m[1] : null;
+}
+
+function extractResource(block, predicate) {
+  const re = new RegExp(predicate + '\\s+([^\\s,;]+)');
+  const m = block.match(re);
+  if (!m) return null;
+  let val = m[1].replace(/[;.]+$/, '');
+  if (val === 'a') return null;
+  return val;
+}
+
+function extractAllResources(block, predicate) {
+  const results = [];
+  const re = new RegExp(predicate + '\\s+', 'g');
+  let match;
+  while ((match = re.exec(block)) !== null) {
+    const rest = block.slice(match.index + match[0].length).trimStart();
+    // Read comma-separated resources until ; or .
+    const tokens = rest.split(/[\s;.\n]+/)[0];
+    if (tokens && tokens !== 'a') {
+      results.push(tokens.replace(/[;,]+$/, ''));
+    }
+  }
+  return [...new Set(results)];
+}
+
+function parseOntology(ttlText) {
+  const rawLines = ttlText.split('\n');
+  // Remove comment lines but keep content
+  const cleaned = rawLines.map(l => l.replace(/#[^\n]*/g, '')).join('\n');
+
+  const blocks = splitSubjectBlocks(cleaned);
+
+  const classes = [];
+  const properties = [];
+
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+
+    // Parse subject
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+
+    // Skip ontology declaration, prefix declarations
+    if (subject === '@prefix' || subject.startsWith('@')) continue;
+    if (subject.includes('glossarist>') && !subject.startsWith('gloss:')) continue;
+
+    // Determine type
+    const typeMatch = trimmed.match(/\ba\s+(.+?)(?:\s*[;.\n]|$)/);
+    if (!typeMatch) continue;
+    const typeStr = typeMatch[1];
+
+    const isClass = /\bowl:Class\b/.test(typeStr);
+    const isObjectProperty = /\bowl:ObjectProperty\b/.test(typeStr);
+    const isDatatypeProperty = /\bowl:DatatypeProperty\b/.test(typeStr);
+
+    if (!isClass && !isObjectProperty && !isDatatypeProperty) continue;
+
+    const label = extractLiteral(trimmed, 'rdfs:label');
+    const comment = extractLiteral(trimmed, 'rdfs:comment');
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+
+    if (isClass) {
+      const subClassOf = extractResource(trimmed, 'rdfs:subClassOf');
+      const disjointWith = extractResource(trimmed, 'owl:disjointWith');
+
+      classes.push({
+        iri,
+        compact,
+        label: label || subject.replace('gloss:', ''),
+        comment,
+        subClassOf: subClassOf ? compactIri(expandPrefixed(subClassOf)) : null,
+        disjointWith: disjointWith ? compactIri(expandPrefixed(disjointWith)) : null,
+      });
+    } else {
+      const domain = extractResource(trimmed, 'rdfs:domain');
+      const range = extractResource(trimmed, 'rdfs:range');
+      const inverseOf = extractResource(trimmed, 'owl:inverseOf');
+
+      // For unionOf domains/ranges, detect the bracket pattern
+      // rdfs:domain [ a owl:Class ; owl:unionOf ( gloss:A gloss:B ) ] ;
+      let domainUnion = null;
+      let rangeUnion = null;
+
+      const unionDomainMatch = trimmed.match(/rdfs:domain\s+\[\s*a\s+owl:Class\s*;\s*owl:unionOf\s*\(([^)]+)\)\s*\]/);
+      if (unionDomainMatch) {
+        domainUnion = unionDomainMatch[1].trim().split(/\s+/).map(t => compactIri(expandPrefixed(t)));
+      }
+
+      const unionRangeMatch = trimmed.match(/rdfs:range\s+\[\s*a\s+owl:Class\s*;\s*owl:unionOf\s*\(([^)]+)\)\s*\]/);
+      if (unionRangeMatch) {
+        rangeUnion = unionRangeMatch[1].trim().split(/\s+/).map(t => compactIri(expandPrefixed(t)));
+      }
+
+      properties.push({
+        iri,
+        compact,
+        label: label || subject.replace('gloss:', ''),
+        comment,
+        type: isObjectProperty ? 'object' : 'datatype',
+        domain: domain ? compactIri(expandPrefixed(domain)) : null,
+        domainUnion: domainUnion,
+        range: range ? compactIri(expandPrefixed(range)) : null,
+        rangeUnion: rangeUnion,
+        inverseOf: inverseOf ? compactIri(expandPrefixed(inverseOf)) : null,
+      });
+    }
+  }
+
+  return { classes, properties };
+}
+
+function buildClassHierarchy(classes) {
+  const map = new Map();
+  for (const c of classes) {
+    map.set(c.compact, c);
+    c.children = [];
+    c.ancestors = [];
+  }
+
+  // Build children
+  for (const c of classes) {
+    if (c.subClassOf && map.has(c.subClassOf)) {
+      map.get(c.subClassOf).children.push(c.compact);
+    }
+  }
+
+  // Build ancestor chains
+  for (const c of classes) {
+    const chain = [];
+    let current = c.subClassOf;
+    while (current && map.has(current)) {
+      chain.push(current);
+      current = map.get(current).subClassOf;
+    }
+    // Add non-glossarist ancestors
+    if (current) chain.push(current);
+    c.ancestors = chain;
+  }
+
+  // Find roots (no subClassOf or subClassOf points outside our ontology)
+  const roots = classes
+    .filter(c => !c.subClassOf || !map.has(c.subClassOf))
+    .map(c => c.compact);
+
+  return { roots, map: Object.fromEntries(map) };
+}
+
+function groupPropertiesByDomain(properties) {
+  const groups = {};
+  for (const p of properties) {
+    const domains = p.domainUnion || (p.domain ? [p.domain] : ['(unspecified)']);
+    for (const d of domains) {
+      if (!groups[d]) groups[d] = { object: [], datatype: [] };
+      groups[d][p.type].push(p.compact);
+    }
+  }
+  return groups;
+}
+
+function main() {
+  if (!existsSync(ONTOLOGY_TTL)) {
+    console.error(`Ontology file not found: ${ONTOLOGY_TTL}`);
+    console.error('Ensure concept-model is available at ../concept-model/');
+    process.exit(1);
+  }
+
+  const ttlText = readFileSync(ONTOLOGY_TTL, 'utf-8');
+  const { classes, properties } = parseOntology(ttlText);
+
+  const hierarchy = buildClassHierarchy(classes);
+  const propsByDomain = groupPropertiesByDomain(properties);
+
+  const output = {
+    ontologyIri: 'https://www.glossarist.org/ontologies/glossarist',
+    ontologyLabel: 'Glossarist Ontology',
+    classes: hierarchy.map,
+    classHierarchyRoots: hierarchy.roots,
+    properties: Object.fromEntries(properties.map(p => [p.compact, p])),
+    propertiesByDomain: propsByDomain,
+    stats: {
+      classCount: classes.length,
+      objectPropertyCount: properties.filter(p => p.type === 'object').length,
+      datatypePropertyCount: properties.filter(p => p.type === 'datatype').length,
+    },
+  };
+
+  mkdirSync(dirname(OUTPUT), { recursive: true });
+  writeFileSync(OUTPUT, JSON.stringify(output, null, 2) + '\n');
+
+  console.log(`Parsed ${output.stats.classCount} classes, ${output.stats.objectPropertyCount} object properties, ${output.stats.datatypePropertyCount} datatype properties`);
+  console.log(`Wrote ${OUTPUT}`);
+}
+
+main();

package/src/__tests__/concept-card.test.ts

@@ -31,7 +31,7 @@ function makeManifest(): Manifest {
 }
 
 function makeEntry(overrides: Partial<ConceptSummary> = {}): ConceptSummary {
-  return { id: '3.1.1.1', eng: 'test term', status: 'valid', ...overrides };
+  return { id: '3.1.1.1', designations: { eng: 'test term' }, eng: 'test term', status: 'valid', ...overrides };
 }
 
 async function createTestRouter() {

package/src/__tests__/concept-detail-interaction.test.ts

@@ -4,7 +4,8 @@ import { createPinia, setActivePinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import ConceptDetail from '../components/ConceptDetail.vue';
 import { useVocabularyStore } from '../stores/vocabulary';
-import type { Manifest, ConceptDocument, LocalizedConcept } from '../adapters/types';
+import type { Manifest } from '../adapters/types';
+import { conceptFromJson } from '../adapters/model-bridge';
 // Prevent the 2.7MB Opal runtime from loading in tests
 vi.mock('../utils/plurimath', () => ({
   loadPlurimath: () => new Promise(() => {}),
@@ -39,7 +40,7 @@ function makeManifest(): Manifest {
   };
 }
 
-function makeConcept(): ConceptDocument {
+function makeConceptJson(overrides: Record<string, any> = {}) {
   return {
     '@context': 'https://glossarist.org/context',
     '@id': 'https://glossarist.org/test/concept/1',
@@ -79,6 +80,7 @@ function makeConcept(): ConceptDocument {
         ],
       },
     },
+    ...overrides,
   };
 }
 
@@ -109,7 +111,8 @@ describe('ConceptDetail interactions', () => {
     store.datasets.set('test', { index: [], getConceptCount: () => 0, getConcepts: () => [], getConceptPosition: () => -1, getIndexEntry: () => undefined } as any);
   });
 
-  function mountDetail(concept = makeConcept()) {
+  function mountDetail(conceptJson: Record<string, any> = makeConceptJson()) {
+    const concept = conceptFromJson(conceptJson);
     return mount(ConceptDetail, {
       global: {
         plugins: [pinia, router],
@@ -130,49 +133,64 @@ describe('ConceptDetail interactions', () => {
     expect(wrapper.find('h1').html()).toContain('test term');
   });
 
+  async function switchToDefinition(wrapper: ReturnType<typeof mountDetail>) {
+    const tabs = wrapper.findAll('button[role="tab"]');
+    const defTab = tabs.find(t => t.text().includes('Definition'));
+    if (defTab) {
+      await defTab.trigger('click');
+      await flushPromises();
+    }
+  }
+
   it('renders concept ID badge', () => {
     const wrapper = mountDetail();
     expect(wrapper.text()).toContain('1');
   });
 
-  it('renders language sections for eng and fra', () => {
+  it('renders language sections for eng and fra', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.text()).toContain('English');
     expect(wrapper.text()).toContain('French');
   });
 
-  it('renders italic text in definition', () => {
+  it('renders italic text in definition', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.html()).toContain('<em>italic</em>');
   });
 
-  it('renders stem: notation as math-pending placeholder', () => {
+  it('renders stem: notation as math-pending placeholder', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.html()).toContain('math-pending');
     expect(wrapper.html()).toContain('data-expr="x"');
   });
 
-  it('renders notes section', () => {
+  it('renders notes section', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.text()).toContain('Note 1');
     expect(wrapper.text()).toContain('a note');
   });
 
-  it('renders examples section', () => {
+  it('renders examples section', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.text()).toContain('Example 1');
     expect(wrapper.text()).toContain('an example');
   });
 
-  it('renders designation types as badges', () => {
+  it('renders designation types as badges', async () => {
     const wrapper = mountDetail();
-    expect(wrapper.text()).toContain('Symbol');
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('symbol');
   });
 
   it('collapses non-eng languages when 6+ languages present', async () => {
-    const concept = makeConcept();
+    const json = makeConceptJson() as Record<string, any>;
     for (const lang of ['deu', 'spa', 'kor', 'jpn']) {
-      concept['gl:localizedConcept']![lang] = {
+      json['gl:localizedConcept'][lang] = {
         '@id': `https://glossarist.org/test/concept/1/${lang}`,
         '@type': 'gl:LocalizedConcept',
         'gl:languageCode': lang,
@@ -184,13 +202,15 @@ describe('ConceptDetail interactions', () => {
         ],
       };
     }
-    const wrapper = mountDetail(concept);
+    const wrapper = mountDetail(json);
+    await switchToDefinition(wrapper);
     await flushPromises();
     expect(wrapper.text()).toContain('6 languages');
   });
 
   it('toggles language section on click', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     const buttons = wrapper.findAll('button');
     const fraButton = buttons.find(b => b.text().includes('French'));
     expect(fraButton).toBeDefined();
@@ -201,6 +221,7 @@ describe('ConceptDetail interactions', () => {
 
   it('switches between definition and history tabs', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.text()).toContain('a definition with');
 
     const tabs = wrapper.findAll('button[role="tab"]');
@@ -213,9 +234,8 @@ describe('ConceptDetail interactions', () => {
   });
 
   it('renders cross-reference link and navigates on click', async () => {
-    const concept = makeConcept();
-    const eng = concept['gl:localizedConcept']!.eng!;
-    eng['gl:definition'] = [
+    const json = makeConceptJson();
+    json['gl:localizedConcept'].eng['gl:definition'] = [
       { '@type': 'gl:DetailedDefinition', 'gl:content': 'see {{urn:iso:std:iso:14812:3.1.1.1,entity}} here' },
     ];
 
@@ -228,7 +248,8 @@ describe('ConceptDetail interactions', () => {
     });
     factory.resolver.registerDataset('test', ['https://glossarist.org/test/concept/*']);
 
-    const wrapper = mountDetail(concept);
+    const wrapper = mountDetail(json);
+    await switchToDefinition(wrapper);
     await flushPromises();
 
     const xref = wrapper.find('.xref-link');
@@ -244,8 +265,9 @@ describe('ConceptDetail interactions', () => {
     expect(wrapper.text()).toContain('valid');
   });
 
-  it('renders the language quick-jump sidebar with all languages', () => {
+  it('renders the language quick-jump sidebar with all languages', async () => {
     const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
     expect(wrapper.text()).toContain('Languages (2)');
   });
 });

package/src/__tests__/concept-formats.test.ts

@@ -1,37 +1,33 @@
 import { describe, it, expect } from 'vitest';
 import { FORMAT_REGISTRY, conceptToTurtle, conceptToSkosJsonLd } from '../utils/concept-formats';
-import type { ConceptDocument } from '../adapters/types';
+import { Concept } from 'glossarist';
 
-function makeConcept(overrides: Partial<ConceptDocument> = {}): ConceptDocument {
-  return {
-    '@context': 'https://glossarist.org/ns/context.jsonld',
-    '@id': 'https://glossarist.org/test/concept/1',
-    '@type': 'gl:Concept',
-    'gl:identifier': '1',
-    'gl:localizedConcept': {
+function makeConcept(overrides: Record<string, unknown> = {}): Concept {
+  return Concept.fromJSON({
+    id: '1',
+    uri: 'https://glossarist.org/test/concept/1',
+    localizations: {
       eng: {
-        '@id': 'https://glossarist.org/test/concept/1/eng',
-        '@type': 'gl:LocalizedConcept',
-        'gl:languageCode': 'eng',
-        'gl:designation': [
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'test term' },
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'admitted', 'gl:term': 'alt term' },
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'test term', normative_status: 'preferred' },
+          { type: 'expression', designation: 'alt term', normative_status: 'admitted' },
         ],
-        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'a definition' }],
-        'gl:notes': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'a note' }],
+        definition: [{ content: 'a definition' }],
+        notes: [{ content: 'a note' }],
       },
       deu: {
-        '@id': 'https://glossarist.org/test/concept/1/deu',
-        '@type': 'gl:LocalizedConcept',
-        'gl:languageCode': 'deu',
-        'gl:designation': [
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'Testbegriff' },
+        language_code: 'deu',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'Testbegriff', normative_status: 'preferred' },
         ],
-        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'eine Definition' }],
+        definition: [{ content: 'eine Definition' }],
       },
     },
     ...overrides,
-  };
+  });
 }
 
 describe('FORMAT_REGISTRY', () => {
@@ -64,17 +60,24 @@ describe('conceptToTurtle', () => {
   });
 
   it('escapes special characters in Turtle', () => {
-    const concept = makeConcept();
-    concept['gl:localizedConcept']!.eng!['gl:definition'] = [
-      { '@type': 'gl:DetailedDefinition', 'gl:content': 'has "quotes" and \\backslash' },
-    ];
+    const concept = Concept.fromJSON({
+      id: '1',
+      uri: 'https://glossarist.org/test/concept/1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{ type: 'expression', designation: 'test', normative_status: 'preferred' }],
+          definition: [{ content: 'has "quotes" and \\backslash' }],
+        },
+      },
+    });
     const ttl = conceptToTurtle(concept);
     expect(ttl).toContain('\\"quotes\\"');
     expect(ttl).toContain('\\\\backslash');
   });
 
   it('handles empty concept gracefully', () => {
-    const ttl = conceptToTurtle({} as ConceptDocument);
+    const ttl = conceptToTurtle(Concept.fromJSON({}));
     expect(ttl).toContain('a skos:Concept');
     expect(ttl).toContain('skos:notation ""');
   });
@@ -100,8 +103,7 @@ describe('conceptToSkosJsonLd', () => {
   });
 
   it('omits empty language maps', () => {
-    const concept = makeConcept();
-    concept['gl:localizedConcept'] = {};
+    const concept = Concept.fromJSON({ id: '1', uri: 'https://glossarist.org/test/concept/1' });
     const parsed = JSON.parse(conceptToSkosJsonLd(concept));
     expect(parsed['skos:prefLabel']).toBeUndefined();
     expect(parsed['skos:definition']).toBeUndefined();