@glossarist/concept-browser 0.2.5 → 0.2.7

package/package.json

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

package/scripts/generate-data.mjs

@@ -90,12 +90,35 @@ function sourcesToJsonLd(sources) {
   });
 }
 
-function refsToJsonLd(refs) {
+function refsToJsonLd(refs, refMaps) {
   if (!refs || !Array.isArray(refs)) return [];
-  return refs.map(r => ({
-    '@id': r.id,
-    'gl:term': r.term,
-  })).filter(r => r['@id']);
+  return refs.map(r => {
+    if (r.id) return { '@id': r.id, 'gl:term': r.term };
+    if (r.term && refMaps) {
+      const uri = resolveRefUri(r.term, refMaps);
+      if (uri) return { '@id': uri, 'gl:term': r.term };
+    }
+    return { '@id': r.id || r.term, 'gl:term': r.term };
+  }).filter(r => r['@id']);
+}
+
+function resolveRefUri(term, refMaps) {
+  const base = refMaps.uriBase;
+  const urnPrefix = 'urn:iso:std:iso:';
+  if (term.startsWith(urnPrefix)) {
+    const rest = term.slice(urnPrefix.length);
+    const match = rest.match(/^(\d+):(.+)$/);
+    if (match) {
+      const dsId = refMaps.urnStandardMap[match[1]];
+      if (dsId) return `${base}/${dsId}/concept/${match[2]}`;
+    }
+  }
+  const ievMatch = term.match(/^IEV:(\d+[-\d]+)$/);
+  if (ievMatch) {
+    const dsId = refMaps.refPrefixMap['IEV'];
+    if (dsId) return `${base}/${dsId}/concept/${ievMatch[1]}`;
+  }
+  return null;
 }
 
 function buildRefMaps(config) {
@@ -119,12 +142,14 @@ function buildRefMaps(config) {
   if (xref.refPrefixMap) Object.assign(refPrefixMap, xref.refPrefixMap);
   if (xref.urnStandardMap) Object.assign(urnStandardMap, xref.urnStandardMap);
 
-  return { refPrefixMap, urnStandardMap };
+  const uriBase = config.uriBase || `https://${config.domain}`;
+  return { refPrefixMap, urnStandardMap, uriBase };
 }
 
-function extractInlineRefs(localizedData, refPrefixMap, urnStandardMap) {
+function extractInlineRefs(localizedData, refMaps) {
   const refs = [];
   const texts = [];
+  const { refPrefixMap, urnStandardMap, uriBase } = refMaps;
 
   if (localizedData.definition) {
     const defs = Array.isArray(localizedData.definition) ? localizedData.definition : [localizedData.definition];
@@ -140,17 +165,17 @@ function extractInlineRefs(localizedData, refPrefixMap, urnStandardMap) {
 
   for (const m of fullText.matchAll(/\{\{([^,}]+),\s*IEV:([^}]+)\}\}/g)) {
     const datasetId = refPrefixMap['IEV'];
-    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: m[1].trim() });
+    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: m[1].trim() });
   }
 
   for (const m of fullText.matchAll(/\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}/g)) {
     const datasetId = urnStandardMap[m[1]];
-    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
   }
 
   for (const m of fullText.matchAll(/\{\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}\}/g)) {
     const datasetId = urnStandardMap[m[1]];
-    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
   }
 
   const seen = new Set();
@@ -165,9 +190,10 @@ const LANG_CODES = ['eng', 'ara', 'deu', 'fra', 'spa', 'ita', 'jpn', 'kor', 'pol
 
 function yamlToJsonLd(conceptYaml, register, refMaps) {
   const termid = String(conceptYaml.termid);
+  const base = refMaps.uriBase;
   const doc = {
     '@context': 'https://glossarist.org/ns/context.jsonld',
-    '@id': `https://glossarist.org/${register}/concept/${termid}`,
+    '@id': `${base}/${register}/concept/${termid}`,
     '@type': 'gl:Concept',
     'gl:identifier': termid,
   };
@@ -178,7 +204,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     if (!lc) continue;
 
     const lDoc = {
-      '@id': `https://glossarist.org/${register}/concept/${termid}/${lang}`,
+      '@id': `${base}/${register}/concept/${termid}/${lang}`,
       '@type': 'gl:LocalizedConcept',
       'gl:languageCode': lang,
     };
@@ -204,11 +230,11 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
       }));
     }
     if (lc.references && lc.references.length > 0) {
-      lDoc['gl:references'] = refsToJsonLd(lc.references);
+      lDoc['gl:references'] = refsToJsonLd(lc.references, refMaps);
     } else if (refMaps) {
-      const inlineRefs = extractInlineRefs(lc, refMaps.refPrefixMap, refMaps.urnStandardMap);
+      const inlineRefs = extractInlineRefs(lc, refMaps);
       if (inlineRefs.length > 0) {
-        lDoc['gl:references'] = refsToJsonLd(inlineRefs);
+        lDoc['gl:references'] = refsToJsonLd(inlineRefs, refMaps);
       }
     }
 
@@ -515,7 +541,7 @@ function processDataset(dir, register, opts) {
   fs.writeFileSync(
     path.join(DATA, register, 'graph-nodes.json'),
     JSON.stringify({
-      uriPrefix: `https://glossarist.org/${register}/concept/`,
+      uriPrefix: `${refMaps.uriBase}/${register}/concept/`,
       registerId: register,
       nodes: graphNodeEntries,
     }),
@@ -583,7 +609,7 @@ function processDataset(dir, register, opts) {
     conceptUrlTemplate: '{baseUrl}/concepts/{conceptId}.json',
     indexUrl: '{baseUrl}/index.json',
     contextUrl: 'https://glossarist.org/ns/context.jsonld',
-    uriBase: 'https://glossarist.org',
+    uriBase: refMaps.uriBase,
     status: 'valid',
     schemaVersion: '1.0.0',
     tags: opts.tags,
@@ -872,6 +898,7 @@ function stripFrontmatter(text) {
 const pageProcessors = {
   news: processNewsPage,
   page: processContentPage,
+  about: processContentPage,
 };
 
 function synthesizePages(config) {

package/src/__tests__/data-integration.test.ts

@@ -56,6 +56,7 @@ describe('AdapterFactory', () => {
       mockFetch.mockReturnValueOnce(mockJsonResponse({
         id: 'test',
         datasetUri: 'https://glossarist.org/test/*',
+        uriBase: 'https://glossarist.org',
         title: 'Test',
         languages: ['eng'],
         chunkSize: 500,
@@ -106,7 +107,7 @@ describe('AdapterFactory', () => {
 
       // Load IEV
       mockFetch.mockReturnValueOnce(mockJsonResponse({
-        id: 'iev', datasetUri: 'urn:iec:std:iec:60050:*', title: 'IEV', languages: ['eng'], chunkSize: 500,
+        id: 'iev', datasetUri: 'urn:iec:std:iec:60050:*', uriBase: 'https://glossarist.org', title: 'IEV', languages: ['eng'], chunkSize: 500,
       }));
       mockFetch.mockReturnValueOnce(mockJsonResponse({
         registerId: 'iev', conceptCount: 0, chunkSize: 500, chunks: [], concepts: [],
@@ -115,7 +116,7 @@ describe('AdapterFactory', () => {
 
       // Load TC 204
       mockFetch.mockReturnValueOnce(mockJsonResponse({
-        id: 'isotc204', datasetUri: 'urn:iso:std:iso:14812:*', title: 'TC 204', languages: ['eng'], chunkSize: 500,
+        id: 'isotc204', datasetUri: 'urn:iso:std:iso:14812:*', uriBase: 'https://glossarist.org', title: 'TC 204', languages: ['eng'], chunkSize: 500,
       }));
       mockFetch.mockReturnValueOnce(mockJsonResponse({
         registerId: 'isotc204', conceptCount: 0, chunkSize: 500, chunks: [], concepts: [],

package/src/__tests__/uri-router.test.ts

@@ -1,10 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { UriRouter } from '../adapters/UriRouter';
 
+const MOCK_MANIFEST = { uriBase: 'https://glossarist.org' } as any;
+
 describe('UriRouter', () => {
   it('resolves URIs for registered datasets', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev');
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
 
     const resolved = router.resolveUri('https://glossarist.org/iev/concept/103-01-02');
     expect(resolved).toEqual({ registerId: 'iev', conceptId: '103-01-02' });
@@ -12,7 +14,7 @@ describe('UriRouter', () => {
 
   it('resolves URIs with multi-part concept IDs', () => {
     const router = new UriRouter();
-    router.registerDataset('isotc204', '/data/isotc204');
+    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
 
     const resolved = router.resolveUri('https://glossarist.org/isotc204/concept/3.1.1.1');
     expect(resolved).toEqual({ registerId: 'isotc204', conceptId: '3.1.1.1' });
@@ -20,36 +22,37 @@ describe('UriRouter', () => {
 
   it('returns null for unknown register', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev');
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
 
     expect(router.resolveUri('https://glossarist.org/unknown/concept/123')).toBeNull();
   });
 
   it('returns null for non-matching URI pattern', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev');
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
 
     expect(router.resolveUri('https://example.com/other')).toBeNull();
   });
 
   it('builds URIs from register and concept ID', () => {
     const router = new UriRouter();
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
     expect(router.buildUri('iev', '103-01-02')).toBe('https://glossarist.org/iev/concept/103-01-02');
   });
 
   it('lists all registered IDs', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev');
-    router.registerDataset('isotc211', '/data/isotc211');
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
 
     expect(router.getRegisteredIds()).toEqual(['iev', 'isotc211']);
   });
 
   it('resolves across multiple registers', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev');
-    router.registerDataset('isotc211', '/data/isotc211');
-    router.registerDataset('isotc204', '/data/isotc204');
+    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
+    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
 
     expect(router.resolveUri('https://glossarist.org/iev/concept/102-01-01')?.registerId).toBe('iev');
     expect(router.resolveUri('https://glossarist.org/isotc211/concept/10')?.registerId).toBe('isotc211');

package/src/adapters/UriRouter.ts

@@ -9,7 +9,7 @@ export class UriRouter {
     this.registerMap.set(registerId, {
       baseUrl,
       manifest: manifest ?? null,
-      uriBase: manifest?.uriBase ?? 'https://glossarist.org',
+      uriBase: manifest?.uriBase ?? '',
     });
   }
 
@@ -31,7 +31,7 @@ export class UriRouter {
 
   buildUri(registerId: string, conceptId: string): string {
     const info = this.registerMap.get(registerId);
-    const uriBase = info?.uriBase ?? 'https://glossarist.org';
+    const uriBase = info?.uriBase ?? '';
     return `${uriBase}/${registerId}/concept/${conceptId}`;
   }
 

package/src/adapters/factory.ts

@@ -50,8 +50,8 @@ export class AdapterFactory {
     const uriPatterns = [
       manifest.datasetUri,
       ...(manifest.uriAliases ?? []),
-      `https://glossarist.org/${registerId}/*`,
-    ];
+      manifest.uriBase ? `${manifest.uriBase}/${registerId}/*` : undefined,
+    ].filter(Boolean) as string[];
     this.resolver.registerDataset(registerId, uriPatterns);
 
     return adapter;

package/src/components/AppSidebar.vue

@@ -130,7 +130,7 @@ function isActive(page: { route: string; datasetScoped?: boolean }): boolean {
         <div class="text-[11px] text-ink-300">
           Built with the
           <a
-            :href="(siteConfig?.features?.poweredBy as any)?.url || 'https://glossarist.org'"
+            :href="(siteConfig?.features?.poweredBy as any)?.url || 'https://github.com/glossarist/concept-browser'"
             target="_blank"
             rel="noopener"
             class="concept-link"

package/src/config/types.ts

@@ -137,6 +137,7 @@ export interface PageConfig {
 export interface SiteConfig {
   id: string;
   domain: string;
+  uriBase?: string;
   title: string;
   subtitle?: string;
   description?: string;

package/src/config/use-site-config.ts

@@ -4,6 +4,7 @@ import type { PageConfig } from './types';
 export interface RuntimeSiteConfig {
   id: string;
   domain: string;
+  uriBase?: string;
   title: string;
   subtitle?: string;
   description?: string;
@@ -106,37 +107,40 @@ async function loadConfig(): Promise<RuntimeSiteConfig | null> {
 }
 
 function synthesizeGlobalPages(features?: Record<string, unknown>, pages?: PageConfig[]): PageConfig[] {
-  if (pages && pages.length > 0) return pages.filter(p => !p.datasetScoped);
+  const declared = pages?.filter(p => !p.datasetScoped) ?? [];
+  const declaredRoutes = new Set(declared.map(p => p.route));
 
   const result: PageConfig[] = [
     { type: 'custom', route: '', title: 'Home', icon: 'home' },
   ];
-  if (features?.search !== false) {
+  if (features?.search !== false && !declaredRoutes.has('search')) {
     result.push({ type: 'custom', route: 'search', title: 'Search', icon: 'search' });
   }
-  if (features?.graph !== false) {
+  if (features?.graph !== false && !declaredRoutes.has('graph')) {
     result.push({ type: 'custom', route: 'graph', title: 'Graph', icon: 'graph' });
   }
-  if (features?.news) {
+  if (features?.news && !declaredRoutes.has('news')) {
     result.push({ type: 'news', route: 'news', title: 'News', icon: 'newspaper' });
   }
-  return result;
+
+  return [...result, ...declared];
 }
 
 function synthesizeDatasetPages(features?: Record<string, unknown>, pages?: PageConfig[]): PageConfig[] {
   const declared = pages?.filter(p => p.datasetScoped) ?? [];
-  if (declared.length > 0) return declared;
+  const declaredRoutes = new Set(declared.map(p => p.route));
 
   const result: PageConfig[] = [
     { type: 'custom', route: '', title: 'Concepts', icon: 'list', datasetScoped: true },
   ];
-  if (features?.stats !== false) {
+  if (features?.stats !== false && !declaredRoutes.has('stats')) {
     result.push({ type: 'stats', route: 'stats', title: 'Statistics', icon: 'chart', datasetScoped: true });
   }
-  if (features?.about !== false) {
+  if (features?.about !== false && !declaredRoutes.has('about')) {
     result.push({ type: 'about', route: 'about', title: 'About', icon: 'info', datasetScoped: true });
   }
-  return result;
+
+  return [...result, ...declared];
 }
 
 export function useSiteConfig() {

package/src/router/index.ts

@@ -27,7 +27,7 @@ const routes: RouteRecordRaw[] = [
   {
     path: '/dataset/:registerId/about',
     name: 'about',
-    component: () => import('../views/AboutView.vue'),
+    component: () => import('../views/PageView.vue'),
     props: true,
   },
   {
@@ -53,7 +53,7 @@ const routes: RouteRecordRaw[] = [
   {
     path: '/about',
     name: 'about-global',
-    component: () => import('../views/AboutView.vue'),
+    component: () => import('../views/PageView.vue'),
   },
   {
     path: '/stats',

package/src/views/PageView.vue

@@ -8,7 +8,14 @@ interface PageData {
 }
 
 const route = useRoute();
-const slug = computed(() => (route.params.slug || route.params.page || '') as string);
+const slug = computed(() => {
+  if (route.params.slug) return route.params.slug as string;
+  if (route.params.page) return route.params.page as string;
+  if (route.name === 'about' || route.name === 'about-global') return 'about';
+  const path = route.path.replace(/^\//, '').replace(/\/$/, '');
+  const lastSegment = path.split('/').pop() || '';
+  return lastSegment;
+});
 const data = ref<PageData | null>(null);
 const loading = ref(true);
 const notFound = ref(false);