@glossarist/concept-browser 0.4.12 → 0.4.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -78,4 +78,4 @@
     "postcss.config.js",
     "env.d.ts"
   ]
-}
+}

package/scripts/generate-ontology-schema.mjs

@@ -13,7 +13,9 @@ 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 CONCEPT_MODEL = resolve(ROOT, '..', 'concept-model', 'ontologies');
+const ONTOLOGY_TTL = resolve(CONCEPT_MODEL, 'glossarist.ttl');
+const SHACL_TTL = resolve(CONCEPT_MODEL, 'shapes', 'glossarist.shacl.ttl');
 const OUTPUT = resolve(ROOT, 'src', 'data', 'ontology-schema.json');
 
 const KNOWN_PREFIXES = {
@@ -27,6 +29,8 @@ const KNOWN_PREFIXES = {
   dcterms: 'http://purl.org/dc/terms/',
   prov: 'http://www.w3.org/ns/prov#',
   xsd: 'http://www.w3.org/2001/XMLSchema#',
+  sh: 'http://www.w3.org/ns/shacl#',
+  vann: 'http://purl.org/vocab/vann/',
 };
 
 function expandPrefixed(term) {
@@ -49,12 +53,14 @@ function compactIri(iri) {
 
 /**
  * Minimal TTL subject-block splitter. Handles nested [] and () and quoted strings.
+ * Tracks <...> URI references to avoid splitting on dots inside URIs.
  */
 function splitSubjectBlocks(text) {
   const blocks = [];
   let depth = 0;
   let start = -1;
   let inTripleQuote = false;
+  let inUri = false;
 
   for (let i = 0; i < text.length; i++) {
     const ch = text[i];
@@ -82,10 +88,20 @@ function splitSubjectBlocks(text) {
       continue;
     }
 
+    if (inUri) {
+      if (ch === '>') inUri = false;
+      continue;
+    }
+    if (ch === '<') {
+      inUri = true;
+      if (start < 0) start = i;
+      continue;
+    }
+
     if (ch === '[' || ch === '(') depth++;
     if (ch === ']' || ch === ')') depth--;
 
-    if (depth === 0 && ch === '.') {
+    if (!inUri && depth === 0 && ch === '.') {
       if (start >= 0) {
         blocks.push(text.slice(start, i));
         start = -1;
@@ -141,10 +157,81 @@ function extractAllResources(block, predicate) {
   return [...new Set(results)];
 }
 
+/**
+ * Strip @prefix and @base lines. Strip comments (#...) but preserve # inside <...> URIs
+ * and inside quoted strings.
+ */
+function preprocessTtl(ttlText) {
+  const lines = ttlText.split('\n');
+  const filtered = lines.filter(l => !l.trimStart().startsWith('@prefix') && !l.trimStart().startsWith('@base'));
+  const text = filtered.join('\n');
+
+  // Character-by-character comment stripping
+  let result = '';
+  let inTriple = false;
+  let inSingle = false;
+  let inUri = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+
+    if (inTriple) {
+      result += ch;
+      if (ch === '"' && text.slice(i, i + 3) === '"""') {
+        result += text.slice(i + 1, i + 3);
+        i += 2;
+        inTriple = false;
+      }
+      continue;
+    }
+
+    if (inSingle) {
+      result += ch;
+      if (ch === '\\') { result += text[i + 1]; i++; continue; }
+      if (ch === '"') inSingle = false;
+      continue;
+    }
+
+    if (inUri) {
+      result += ch;
+      if (ch === '>') inUri = false;
+      continue;
+    }
+
+    if (ch === '"' && text.slice(i, i + 3) === '"""') {
+      result += '"""';
+      inTriple = true;
+      i += 2;
+      continue;
+    }
+
+    if (ch === '"') {
+      result += ch;
+      inSingle = true;
+      continue;
+    }
+
+    if (ch === '<') {
+      result += ch;
+      inUri = true;
+      continue;
+    }
+
+    if (ch === '#') {
+      // Skip until end of line
+      while (i < text.length && text[i] !== '\n') i++;
+      if (i < text.length) result += '\n';
+      continue;
+    }
+
+    result += ch;
+  }
+
+  return result;
+}
+
 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 cleaned = preprocessTtl(ttlText);
 
   const blocks = splitSubjectBlocks(cleaned);
 
@@ -160,8 +247,7 @@ function parseOntology(ttlText) {
     if (!subjectMatch) continue;
     const subject = subjectMatch[1];
 
-    // Skip ontology declaration, prefix declarations
-    if (subject === '@prefix' || subject.startsWith('@')) continue;
+    // Skip ontology declaration
     if (subject.includes('glossarist>') && !subject.startsWith('gloss:')) continue;
 
     // Determine type
@@ -278,6 +364,176 @@ function groupPropertiesByDomain(properties) {
   return groups;
 }
 
+/**
+ * Extract individual sh:property [...] constraint blocks from a shape block.
+ * Returns an array of strings, each being the inner content of one [ ... ].
+ */
+function extractPropertyBlocks(shapeBlock) {
+  const blocks = [];
+  const re = /sh:property\s+\[/g;
+  let match;
+  while ((match = re.exec(shapeBlock)) !== null) {
+    const start = match.index + match[0].length - 1; // position of '['
+    let depth = 1;
+    let i = start + 1;
+    while (i < shapeBlock.length && depth > 0) {
+      if (shapeBlock[i] === '[') depth++;
+      else if (shapeBlock[i] === ']') depth--;
+      i++;
+    }
+    blocks.push(shapeBlock.slice(start + 1, i - 1));
+  }
+  return blocks;
+}
+
+function parseConstraint(propBlock) {
+  const c = {};
+  const path = extractResource(propBlock, 'sh:path');
+  c.path = path ? compactIri(expandPrefixed(path)) : null;
+
+  const dt = extractResource(propBlock, 'sh:datatype');
+  c.datatype = dt ? compactIri(expandPrefixed(dt)) : null;
+
+  const cls = extractResource(propBlock, 'sh:class');
+  c.class = cls ? compactIri(expandPrefixed(cls)) : null;
+
+  const vf = extractResource(propBlock, 'sh:valuesFrom');
+  c.valuesFrom = vf ? compactIri(expandPrefixed(vf)) : null;
+
+  const nk = extractResource(propBlock, 'sh:nodeKind');
+  c.nodeKind = nk ? compactIri(expandPrefixed(nk)) : null;
+
+  const minMatch = propBlock.match(/sh:minCount\s+(\d+)/);
+  c.minCount = minMatch ? parseInt(minMatch[1], 10) : null;
+
+  const maxMatch = propBlock.match(/sh:maxCount\s+(\d+)/);
+  c.maxCount = maxMatch ? parseInt(maxMatch[1], 10) : null;
+
+  // sh:in ( "val1" "val2" ... )
+  const inMatch = propBlock.match(/sh:in\s*\(([^)]+)\)/);
+  if (inMatch) {
+    c.in = inMatch[1].match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || null;
+  } else {
+    c.in = null;
+  }
+
+  return c;
+}
+
+function parseShaclShapes(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+
+  const shapes = [];
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+
+    // Check if this is a sh:NodeShape
+    if (!/\ba\s+sh:NodeShape\b/.test(trimmed)) continue;
+
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+    const label = extractLiteral(trimmed, 'rdfs:label');
+    const comment = extractLiteral(trimmed, 'rdfs:comment');
+    const targetClass = extractResource(trimmed, 'sh:targetClass');
+
+    const propBlocks = extractPropertyBlocks(trimmed);
+    const constraints = propBlocks.map(parseConstraint).filter(c => c.path);
+
+    // sh:class at shape level (not inside sh:property blocks)
+    const shapeClassMatch = trimmed.match(/^\s*[^[]*?\ba\s+sh:NodeShape\s[^[]*?sh:class\s+([^\s,;]+)/);
+    const shapeClass = shapeClassMatch ? shapeClassMatch[1].replace(/[;.]+$/, '') : null;
+
+    shapes.push({
+      iri,
+      compact,
+      label: label || subject.replace('gloss:', '').replace('Shape', ''),
+      comment,
+      targetClass: targetClass ? compactIri(expandPrefixed(targetClass)) : null,
+      shapeClass: shapeClass ? compactIri(expandPrefixed(shapeClass)) : null,
+      constraints,
+    });
+  }
+
+  return shapes;
+}
+
+const IMPORT_LABELS = {
+  'http://www.w3.org/2004/02/skos/core': 'SKOS',
+  'http://www.w3.org/2004/02/skos/core#': 'SKOS',
+  'http://www.w3.org/2008/05/skos-xl': 'SKOS-XL',
+  'http://www.w3.org/2008/05/skos-xl#': 'SKOS-XL',
+  'http://purl.org/iso25964/skos-thes': 'ISO 25964',
+  'http://purl.org/iso25964/skos-thes#': 'ISO 25964',
+  'http://www.w3.org/ns/prov#': 'PROV-O',
+  'http://purl.org/dc/terms/': 'Dublin Core Terms',
+};
+
+function parseOntologyDeclaration(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+
+    // Match the owl:Ontology declaration
+    if (!/\ba\s+owl:Ontology\b/.test(trimmed)) continue;
+
+    const subjectMatch = trimmed.match(/^<([^>]+)>/);
+    const iri = subjectMatch ? subjectMatch[1] : null;
+    const label = extractLiteral(trimmed, 'rdfs:label') || extractLiteral(trimmed, 'dcterms:title');
+    const comment = extractLiteral(trimmed, 'rdfs:comment') || extractLiteral(trimmed, 'dcterms:description');
+    const prefix = extractLiteral(trimmed, 'vann:preferredNamespacePrefix');
+    const nsUri = extractLiteral(trimmed, 'vann:preferredNamespaceUri');
+    const license = extractResource(trimmed, 'dcterms:license')?.replace(/[<>]/g, '') || null;
+    const created = extractLiteral(trimmed, 'dcterms:created');
+
+    const imports = [];
+    const importRe = /owl:imports\s+<([^>]+)>/g;
+    let im;
+    while ((im = importRe.exec(trimmed)) !== null) {
+      const iri = im[1];
+      imports.push({
+        iri,
+        label: IMPORT_LABELS[iri] || IMPORT_LABELS[iri.replace(/#?$/, '#')] || compactIri(iri),
+      });
+    }
+
+    return { iri, label, comment, prefix, namespaceUri: nsUri, imports, license, created };
+  }
+  return null;
+}
+
+function parseAnnotationProperties(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+
+  const props = [];
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+
+    if (!/\ba\s+owl:AnnotationProperty\b/.test(trimmed)) continue;
+
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+    const label = extractLiteral(trimmed, 'rdfs:label');
+
+    props.push({ iri, compact, label: label || compact });
+  }
+
+  return props;
+}
+
 function main() {
   if (!existsSync(ONTOLOGY_TTL)) {
     console.error(`Ontology file not found: ${ONTOLOGY_TTL}`);
@@ -291,24 +547,70 @@ function main() {
   const hierarchy = buildClassHierarchy(classes);
   const propsByDomain = groupPropertiesByDomain(properties);
 
+  let shapes = [];
+  if (existsSync(SHACL_TTL)) {
+    const shaclText = readFileSync(SHACL_TTL, 'utf-8');
+    shapes = parseShaclShapes(shaclText);
+  } else {
+    console.warn(`SHACL shapes file not found: ${SHACL_TTL}`);
+  }
+
+  const ontologyDecl = parseOntologyDeclaration(ttlText);
+  let annotationProps = parseAnnotationProperties(ttlText);
+
+  // Hardcode standard annotation properties used in the ontology (not declared as owl:AnnotationProperty)
+  if (annotationProps.length === 0) {
+    annotationProps = [
+      { iri: 'http://www.w3.org/2000/01/rdf-schema#label', compact: 'rdfs:label', label: 'label' },
+      { iri: 'http://www.w3.org/2000/01/rdf-schema#comment', compact: 'rdfs:comment', label: 'comment' },
+      { iri: 'http://www.w3.org/2000/01/rdf-schema#seeAlso', compact: 'rdfs:seeAlso', label: 'seeAlso' },
+      { iri: 'http://www.w3.org/2000/01/rdf-schema#isDefinedBy', compact: 'rdfs:isDefinedBy', label: 'isDefinedBy' },
+      { iri: 'http://purl.org/dc/terms/title', compact: 'dcterms:title', label: 'title' },
+      { iri: 'http://purl.org/dc/terms/description', compact: 'dcterms:description', label: 'description' },
+      { iri: 'http://purl.org/dc/terms/source', compact: 'dcterms:source', label: 'source' },
+      { iri: 'http://purl.org/dc/terms/license', compact: 'dcterms:license', label: 'license' },
+      { iri: 'http://purl.org/dc/terms/created', compact: 'dcterms:created', label: 'created' },
+      { iri: 'http://purl.org/vocab/vann/preferredNamespacePrefix', compact: 'vann:preferredNamespacePrefix', label: 'preferredNamespacePrefix' },
+      { iri: 'http://purl.org/vocab/vann/preferredNamespaceUri', compact: 'vann:preferredNamespaceUri', label: 'preferredNamespaceUri' },
+    ];
+  }
+
+  // Group shapes by targetClass
+  const shapesByTargetClass = {};
+  for (const s of shapes) {
+    const tc = s.targetClass || '(unspecified)';
+    if (!shapesByTargetClass[tc]) shapesByTargetClass[tc] = [];
+    shapesByTargetClass[tc].push(s.compact);
+  }
+
   const output = {
-    ontologyIri: 'https://www.glossarist.org/ontologies/glossarist',
-    ontologyLabel: 'Glossarist Ontology',
+    ontology: ontologyDecl,
+    ontologyIri: ontologyDecl?.iri || 'https://www.glossarist.org/ontologies/glossarist',
+    ontologyLabel: ontologyDecl?.label || 'Glossarist Ontology',
     classes: hierarchy.map,
     classHierarchyRoots: hierarchy.roots,
     properties: Object.fromEntries(properties.map(p => [p.compact, p])),
     propertiesByDomain: propsByDomain,
+    shapes: Object.fromEntries(shapes.map(s => [s.compact, s])),
+    shapesByTargetClass,
+    annotationProperties: annotationProps,
     stats: {
       classCount: classes.length,
       objectPropertyCount: properties.filter(p => p.type === 'object').length,
       datatypePropertyCount: properties.filter(p => p.type === 'datatype').length,
+      shapeCount: shapes.length,
+      annotationPropertyCount: annotationProps.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(`Parsed ${output.stats.classCount} classes, ${output.stats.objectPropertyCount} object properties, ${output.stats.datatypePropertyCount} datatype properties, ${output.stats.shapeCount} SHACL shapes, ${output.stats.annotationPropertyCount} annotation properties`);
+  if (ontologyDecl) {
+    console.log(`Ontology: ${ontologyDecl.iri}`);
+    console.log(`  imports: ${ontologyDecl.imports.map(i => i.label).join(', ')}`);
+  }
   console.log(`Wrote ${OUTPUT}`);
 }
 

package/src/adapters/ontology-schema.ts

@@ -1,5 +1,5 @@
 /**
- * Ontology schema loader — provides class/property definitions parsed from
+ * Ontology schema loader — provides class/property/shape definitions parsed from
  * the Glossarist OWL ontology for the Ontospy-style concept view.
  */
 import schemaData from '../data/ontology-schema.json';
@@ -28,14 +28,72 @@ export interface OwlProperty {
   inverseOf: string | null;
 }
 
+export interface ShaclConstraint {
+  path: string | null;
+  datatype: string | null;
+  class: string | null;
+  valuesFrom: string | null;
+  nodeKind: string | null;
+  minCount: number | null;
+  maxCount: number | null;
+  in: string[] | null;
+}
+
+export interface OwlShape {
+  iri: string;
+  compact: string;
+  label: string;
+  comment: string | null;
+  targetClass: string | null;
+  shapeClass: string | null;
+  constraints: ShaclConstraint[];
+}
+
+export interface OwlOntology {
+  iri: string;
+  label: string;
+  comment: string | null;
+  prefix: string | null;
+  namespaceUri: string | null;
+  imports: { iri: string; label: string }[];
+  license: string | null;
+  created: string | null;
+}
+
+export interface AnnotationProperty {
+  iri: string;
+  compact: string;
+  label: string;
+}
+
+export type EntityType = 'class' | 'objectProperty' | 'datatypeProperty' | 'shape' | 'annotationProperty';
+
+export const ENTITY_TYPE_META: Record<EntityType, { label: string; color: string }> = {
+  class: { label: 'Classes', color: 'blue' },
+  objectProperty: { label: 'Object Properties', color: 'emerald' },
+  datatypeProperty: { label: 'Datatype Properties', color: 'amber' },
+  shape: { label: 'SHACL Shapes', color: 'purple' },
+  annotationProperty: { label: 'Annotation Properties', color: 'pink' },
+};
+
 interface OntologySchema {
+  ontology: OwlOntology | null;
   ontologyIri: string;
   ontologyLabel: string;
   classes: Record<string, OwlClass>;
   classHierarchyRoots: string[];
   properties: Record<string, OwlProperty>;
   propertiesByDomain: Record<string, { object: string[]; datatype: string[] }>;
-  stats: { classCount: number; objectPropertyCount: number; datatypePropertyCount: number };
+  shapes: Record<string, OwlShape>;
+  shapesByTargetClass: Record<string, string[]>;
+  annotationProperties: AnnotationProperty[];
+  stats: {
+    classCount: number;
+    objectPropertyCount: number;
+    datatypePropertyCount: number;
+    shapeCount: number;
+    annotationPropertyCount: number;
+  };
 }
 
 const data = schemaData as unknown as OntologySchema;
@@ -48,6 +106,10 @@ export function getProperty(id: string): OwlProperty | null {
   return data.properties[id] ?? null;
 }
 
+export function getShape(id: string): OwlShape | null {
+  return data.shapes[id] ?? null;
+}
+
 export function getPropertiesForDomain(domain: string): { object: OwlProperty[]; datatype: OwlProperty[] } {
   const group = data.propertiesByDomain[domain];
   if (!group) return { object: [], datatype: [] };
@@ -57,7 +119,6 @@ export function getPropertiesForDomain(domain: string): { object: OwlProperty[];
   };
 }
 
-/** Get all properties applicable to a class, including inherited ones. */
 export function getAllPropertiesForClass(classId: string): { object: OwlProperty[]; datatype: OwlProperty[] } {
   const cls = data.classes[classId];
   if (!cls) return { object: [], datatype: [] };
@@ -80,7 +141,11 @@ export function getAllPropertiesForClass(classId: string): { object: OwlProperty
   return { object: objectProps, datatype: datatypeProps };
 }
 
-/** Get the full class hierarchy tree starting from roots. */
+export function getShapesForClass(classId: string): OwlShape[] {
+  const shapeIds = data.shapesByTargetClass[classId] ?? [];
+  return shapeIds.map(id => data.shapes[id]).filter(Boolean);
+}
+
 export function getClassTree(): OwlClass[] {
   return data.classHierarchyRoots
     .map(id => data.classes[id])
@@ -95,6 +160,26 @@ export function getAllProperties(): OwlProperty[] {
   return Object.values(data.properties);
 }
 
+export function getObjectProperties(): OwlProperty[] {
+  return Object.values(data.properties).filter(p => p.type === 'object');
+}
+
+export function getDatatypeProperties(): OwlProperty[] {
+  return Object.values(data.properties).filter(p => p.type === 'datatype');
+}
+
+export function getAllShapes(): OwlShape[] {
+  return Object.values(data.shapes);
+}
+
+export function getAnnotationProperties(): AnnotationProperty[] {
+  return data.annotationProperties;
+}
+
+export function getOntology(): OwlOntology | null {
+  return data.ontology;
+}
+
 export function getStats() {
   return data.stats;
 }