@glossarist/concept-browser 0.1.0 → 0.1.2

package/package.json

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

package/scripts/build-edges.js

@@ -89,6 +89,11 @@ function buildEdgesForDataset(datasetDir, registerId) {
 // Main
 console.log('Building edge indexes...\n');
 
+if (!existsSync(DATA_DIR)) {
+  console.log('No data directory found. Nothing to do.');
+  process.exit(0);
+}
+
 const datasets = readdirSync(DATA_DIR).filter(f => {
   try {
     return existsSync(join(DATA_DIR, f, 'manifest.json'));

package/scripts/generate-data.mjs

@@ -221,6 +221,42 @@ function conceptJsonToTurtle(concept) {
   return lines.join('\n');
 }
 
+function conceptJsonToSkosJsonLd(concept) {
+  const uri = concept['@id'] || '';
+  const id = concept['gl:identifier'] || '';
+
+  const doc = {
+    '@context': {
+      skos: 'http://www.w3.org/2004/02/skos/core#',
+      dcterms: 'http://purl.org/dc/terms/',
+      '@language': { '@container': '@language' },
+    },
+    '@id': uri,
+    '@type': 'skos:Concept',
+    'skos:notation': id,
+  };
+
+  const prefLabels = {}, altLabels = {}, definitions = {}, scopeNotes = {};
+  for (const [lang, lc] of Object.entries(concept['gl:localizedConcept'] || {})) {
+    const descs = lc['gl:designation'] || [];
+    const pref = descs.find(d => d['gl:normativeStatus'] === 'preferred' && d['gl:term']);
+    const alt = descs.find(d => d['gl:normativeStatus'] !== 'preferred' && d['gl:term']);
+    if (pref) prefLabels[lang] = pref['gl:term'];
+    if (alt) altLabels[lang] = alt['gl:term'];
+    const def = (lc['gl:definition'] || [])[0];
+    if (def?.['gl:content']) definitions[lang] = def['gl:content'];
+    const note = (lc['gl:notes'] || [])[0];
+    if (note?.['gl:content']) scopeNotes[lang] = note['gl:content'];
+  }
+
+  if (Object.keys(prefLabels).length) doc['skos:prefLabel'] = prefLabels;
+  if (Object.keys(altLabels).length) doc['skos:altLabel'] = altLabels;
+  if (Object.keys(definitions).length) doc['skos:definition'] = definitions;
+  if (Object.keys(scopeNotes).length) doc['skos:scopeNote'] = scopeNotes;
+
+  return JSON.stringify(doc, null, 2);
+}
+
 function processDataset(dir, register, opts) {
   const files = fs.readdirSync(dir).filter(f => f.endsWith('.yaml')).sort((a, b) => naturalSort(a.replace('.yaml', ''), b.replace('.yaml', '')));
 
@@ -230,7 +266,7 @@ function processDataset(dir, register, opts) {
   const concepts = [];
   const langTermCounts = {};
   const langDefCounts = {};
-  const availableFormats = ['ttl', 'yaml'];
+  const availableFormats = ['ttl', 'jsonld', 'yaml'];
 
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
@@ -246,6 +282,10 @@ function processDataset(dir, register, opts) {
       const ttlContent = conceptJsonToTurtle(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.ttl`), ttlContent);
 
+      // Generate SKOS JSON-LD format
+      const skosJsonLd = conceptJsonToSkosJsonLd(jsonld);
+      fs.writeFileSync(path.join(conceptsDir, `${termid}.jsonld`), skosJsonLd);
+
       // Copy source YAML
       fs.copyFileSync(path.join(dir, file), path.join(conceptsDir, `${termid}.yaml`));
 
@@ -569,14 +609,14 @@ const processedPages = processPages(config);
 
 // Generate site-config.json from site config
 const siteBranding = { ...config.branding };
-// Rewrite logo paths to downloaded filenames
-if (siteBranding.logo?.remoteUrl) {
-  siteBranding.logo = { ...siteBranding.logo, path: `/logos/${config.id}-logo.svg` };
-  delete siteBranding.logo.remoteUrl;
-}
-if (siteBranding.footerLogo?.remoteUrl) {
-  siteBranding.footerLogo = { ...siteBranding.footerLogo, path: `/logos/${config.id}-footer-logo.svg` };
-  delete siteBranding.footerLogo.remoteUrl;
+// Rewrite logo paths to destination filenames and strip build-time fields
+for (const key of ['logo', 'footerLogo']) {
+  const suffix = key === 'logo' ? 'logo.svg' : 'footer-logo.svg';
+  if (siteBranding[key]) {
+    siteBranding[key] = { ...siteBranding[key], path: `/logos/${config.id}-${suffix}` };
+    delete siteBranding[key].localPath;
+    delete siteBranding[key].remoteUrl;
+  }
 }
 
 writeJson(path.join(PUBLIC, 'site-config.json'), {

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

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { FORMAT_REGISTRY, conceptToTurtle, conceptToSkosJsonLd } from '../utils/concept-formats';
+import type { ConceptDocument } from '../adapters/types';
+
+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': {
+      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' },
+        ],
+        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'a definition' }],
+        'gl:notes': [{ '@type': 'gl:DetailedDefinition', 'gl: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' },
+        ],
+        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'eine Definition' }],
+      },
+    },
+    ...overrides,
+  };
+}
+
+describe('FORMAT_REGISTRY', () => {
+  it('has ttl, jsonld, yaml entries', () => {
+    expect(FORMAT_REGISTRY.ttl).toBeDefined();
+    expect(FORMAT_REGISTRY.jsonld).toBeDefined();
+    expect(FORMAT_REGISTRY.yaml).toBeDefined();
+  });
+
+  it('each entry has extension, label, mediaType', () => {
+    for (const [, desc] of Object.entries(FORMAT_REGISTRY)) {
+      expect(desc.extension).toBeTruthy();
+      expect(desc.label).toBeTruthy();
+      expect(desc.mediaType).toBeTruthy();
+    }
+  });
+});
+
+describe('conceptToTurtle', () => {
+  it('generates valid Turtle with SKOS predicates', () => {
+    const ttl = conceptToTurtle(makeConcept());
+    expect(ttl).toContain('@prefix skos:');
+    expect(ttl).toContain('a skos:Concept');
+    expect(ttl).toContain('skos:prefLabel "test term"@eng');
+    expect(ttl).toContain('skos:altLabel "alt term"@eng');
+    expect(ttl).toContain('skos:prefLabel "Testbegriff"@deu');
+    expect(ttl).toContain('skos:definition "a definition"@eng');
+    expect(ttl).toContain('skos:scopeNote "a note"@eng');
+    expect(ttl).toContain('skos:notation "1"');
+  });
+
+  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 ttl = conceptToTurtle(concept);
+    expect(ttl).toContain('\\"quotes\\"');
+    expect(ttl).toContain('\\\\backslash');
+  });
+
+  it('handles empty concept gracefully', () => {
+    const ttl = conceptToTurtle({} as ConceptDocument);
+    expect(ttl).toContain('a skos:Concept');
+    expect(ttl).toContain('skos:notation ""');
+  });
+});
+
+describe('conceptToSkosJsonLd', () => {
+  it('generates SKOS JSON-LD with language maps', () => {
+    const jsonld = conceptToSkosJsonLd(makeConcept());
+    const parsed = JSON.parse(jsonld);
+
+    expect(parsed['@type']).toBe('skos:Concept');
+    expect(parsed['@id']).toBe('https://glossarist.org/test/concept/1');
+    expect(parsed['skos:notation']).toBe('1');
+    expect(parsed['skos:prefLabel']).toEqual({ eng: 'test term', deu: 'Testbegriff' });
+    expect(parsed['skos:altLabel']).toEqual({ eng: 'alt term' });
+    expect(parsed['skos:definition']).toEqual({ eng: 'a definition', deu: 'eine Definition' });
+  });
+
+  it('uses @language container in context', () => {
+    const jsonld = conceptToSkosJsonLd(makeConcept());
+    const parsed = JSON.parse(jsonld);
+    expect(parsed['@context']['@language']).toEqual({ '@container': '@language' });
+  });
+
+  it('omits empty language maps', () => {
+    const concept = makeConcept();
+    concept['gl:localizedConcept'] = {};
+    const parsed = JSON.parse(conceptToSkosJsonLd(concept));
+    expect(parsed['skos:prefLabel']).toBeUndefined();
+    expect(parsed['skos:definition']).toBeUndefined();
+  });
+});

package/src/utils/concept-formats.ts

@@ -1,9 +1,4 @@
-/**
- * Format registry and converters for per-concept format downloads.
- *
- * Open/closed: add a new format by adding an entry to FORMAT_REGISTRY
- * and a converter function. No changes to components needed.
- */
+import type { ConceptDocument, LocalizedConcept } from '../adapters/types';
 
 export interface FormatDescriptor {
   extension: string;
@@ -13,33 +8,8 @@ export interface FormatDescriptor {
 
 export const FORMAT_REGISTRY: Record<string, FormatDescriptor> = {
   ttl: { extension: 'ttl', label: 'Turtle RDF', mediaType: 'text/turtle' },
-  jsonld: { extension: 'jsonld', label: 'JSON-LD (SKOS)', mediaType: 'application/ld+json' },
+  jsonld: { extension: 'jsonld', label: 'JSON-LD', mediaType: 'application/ld+json' },
   yaml: { extension: 'yaml', label: 'YAML', mediaType: 'text/yaml' },
-  tbx: { extension: 'tbx', label: 'TBX', mediaType: 'application/xml' },
-};
-
-export type ConceptDesignation = {
-  '@type'?: string;
-  'gl:normativeStatus'?: string;
-  'gl:term'?: string;
-};
-
-export type ConceptDefinition = {
-  'gl:content'?: string;
-};
-
-export type ConceptLocalized = {
-  'gl:languageCode'?: string;
-  'gl:designation'?: ConceptDesignation[];
-  'gl:definition'?: ConceptDefinition[];
-  'gl:notes'?: ConceptDefinition[];
-  'gl:source'?: any[];
-};
-
-export type ConceptDocument = {
-  '@id'?: string;
-  'gl:identifier'?: string;
-  'gl:localizedConcept'?: Record<string, ConceptLocalized>;
 };
 
 function getLocalizedData(concept: ConceptDocument) {
@@ -77,9 +47,6 @@ function escapeTurtle(s: string): string {
   return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
 }
 
-/**
- * Convert a concept document to SKOS Turtle.
- */
 export function conceptToTurtle(concept: ConceptDocument): string {
   const uri = concept['@id'] || '';
   const id = concept['gl:identifier'] || '';
@@ -88,7 +55,6 @@ export function conceptToTurtle(concept: ConceptDocument): string {
   const lines: string[] = [
     '@prefix skos: <http://www.w3.org/2004/02/skos/core#> .',
     '@prefix dcterms: <http://purl.org/dc/terms/> .',
-    '@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .',
     '',
   ];
 
@@ -117,9 +83,6 @@ export function conceptToTurtle(concept: ConceptDocument): string {
   return lines.join('\n');
 }
 
-/**
- * Convert a concept document to SKOS JSON-LD.
- */
 export function conceptToSkosJsonLd(concept: ConceptDocument): string {
   const uri = concept['@id'] || '';
   const id = concept['gl:identifier'] || '';

package/tailwind.config.js

@@ -1,9 +1,14 @@
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 /** @type {import('tailwindcss').Config} */
 export default {
   darkMode: 'class',
   content: [
-    "./index.html",
-    "./src/**/*.{vue,js,ts,jsx,tsx}",
+    resolve(__dirname, "index.html"),
+    resolve(__dirname, "src/**/*.{vue,js,ts,jsx,tsx}"),
   ],
   theme: {
     extend: {