@glossarist/concept-browser 0.7.139 → 0.7.140

package/package.json

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

package/scripts/__tests__/standards-index.test.ts

@@ -0,0 +1,121 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+describe('generate-data standards index', () => {
+  it('emits unique authoritative standards per register and preserves source stats', () => {
+    const root = mkdtempSync(join(tmpdir(), 'generate-data-standards-'));
+    const conceptsDir = join(root, 'source', 'concepts');
+    const outputDir = join(root, 'public', 'data', 'fixture');
+    const configPath = join(root, 'site-config.yml');
+    const generator = resolve('scripts/generate-data.ts');
+    const tsx = resolve('node_modules/tsx/dist/loader.mjs');
+
+    try {
+      mkdirSync(conceptsDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify({
+        id: 'fixture', title: 'Fixture', uri_base: 'https://example.test',
+        datasets: [{ id: 'fixture', local_path: 'source', languages: ['eng', 'fra'] }],
+      }));
+      const writeConcept = (id: string, sources: unknown[], engSources: unknown[] = []) => {
+        writeFileSync(join(conceptsDir, `${id}.yaml`), JSON.stringify({
+          termid: id,
+          _sources: sources,
+          eng: {
+            terms: [{ designation: `Fixture term ${id}` }],
+            sources: engSources,
+          },
+        }));
+      };
+      writeConcept('1', [
+        { type: 'authoritative', origin: { ref: { source: 'ISO', id: '19165-2:2020', clause: '3.1' } } },
+        { type: 'authoritative', origin: { ref: { source: 'ISO', id: '19165-2:2020', clause: '4.2' } } },
+        { type: 'authoritative', origin: { ref: { source: 'IEC', id: '17000:2020' } } },
+        { type: 'lineage', origin: { ref: { source: 'ISO', id: '704:2022' } } },
+      ], [
+        { type: 'authoritative', origin: { ref: { source: 'iso', id: '19165-2:2020', clause: '5.1' } } },
+      ]);
+      writeConcept('2', [
+        { type: 'authoritative', origin: { ref: { source: ' ISO ', id: ' 19165-2:2020 ', clause: '6.3' } } },
+      ]);
+      writeConcept('3', [
+        { type: 'lineage', origin: { ref: { source: 'ISO', id: '999:2020' } } },
+      ], [
+        { type: 'authoritative', origin: { ref: { source: 'ISO', id: '1087:2019' } } },
+      ]);
+
+      execFileSync(process.execPath, ['--import', tsx, generator], {
+        cwd: root,
+        env: { ...process.env, SITE_CONFIG: configPath },
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+
+      const standards = JSON.parse(readFileSync(join(outputDir, 'standards.json'), 'utf8'));
+      expect(standards).toEqual({
+        'iso 19165-2:2020': { label: 'ISO 19165-2:2020', conceptIds: ['1', '2'] },
+        'iec 17000:2020': { label: 'IEC 17000:2020', conceptIds: ['1'] },
+        'iso 1087:2019': { label: 'ISO 1087:2019', conceptIds: ['3'] },
+      });
+
+      const stats = JSON.parse(readFileSync(join(outputDir, 'stats.json'), 'utf8'));
+      expect(stats.sourceCount).toBe(4);
+      expect(stats.sources).toEqual(expect.arrayContaining([
+        expect.objectContaining({ ref: 'ISO', conceptCount: 2, conceptIds: ['1', '3'] }),
+        expect.objectContaining({ ref: 'IEC', conceptCount: 1, conceptIds: ['1'] }),
+      ]));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }, 60_000);
+
+  it('includes authoritative standards from languages absent from the dataset config', () => {
+    const root = mkdtempSync(join(tmpdir(), 'generate-data-unconfigured-language-'));
+    const conceptsDir = join(root, 'source', 'concepts');
+    const configPath = join(root, 'site-config.yml');
+    try {
+      mkdirSync(conceptsDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify({
+        id: 'fixture', title: 'Fixture', uri_base: 'https://example.test',
+        datasets: [{ id: 'fixture', local_path: 'source', languages: ['eng'] }],
+      }));
+      writeFileSync(join(conceptsDir, '1.yaml'), JSON.stringify({
+        termid: '1',
+        eng: {
+          terms: [{ designation: 'Term' }],
+          sources: [{ type: 'authoritative', origin: { ref: { source: 'ISO' } } }],
+        },
+        deu: {
+          terms: [{ designation: 'Begriff' }],
+          sources: [
+            { type: 'authoritative', origin: { ref: { source: 'DIN', id: '1' } } },
+            { type: 'lineage', origin: { ref: { source: 'DIN', id: '2' } } },
+          ],
+        },
+      }));
+      execFileSync(process.execPath, [
+        '--import', resolve('node_modules/tsx/dist/loader.mjs'), resolve('scripts/generate-data.ts'),
+      ], {
+        cwd: root,
+        env: { ...process.env, SITE_CONFIG: configPath },
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+      const outputDir = join(root, 'public', 'data', 'fixture');
+      expect(JSON.parse(readFileSync(join(outputDir, 'standards.json'), 'utf8'))).toEqual({
+        iso: { label: 'ISO', conceptIds: ['1'] },
+        'din 1': { label: 'DIN 1', conceptIds: ['1'] },
+      });
+      const stats = JSON.parse(readFileSync(join(outputDir, 'stats.json'), 'utf8'));
+      expect(stats.sourceCount).toBe(1);
+      expect(stats.sources).toEqual([
+        { ref: 'ISO', types: ['authoritative'], conceptCount: 1, conceptIds: ['1'] },
+      ]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/scripts/generate-data.js

@@ -1,6 +1,7 @@
 // scripts/generate-data.ts
 import fs2 from "fs";
 import path3 from "path";
+import { createHash as createHash2 } from "node:crypto";
 import yaml4 from "js-yaml";
 import {
   naturalSort,
@@ -89,6 +90,28 @@ function loadSiteConfig(args = []) {
   return { config: config2, configPath };
 }
 
+// src/utils/source-standard.ts
+function standardLabel(ref) {
+  const parts = [ref?.source, ref?.id].map((part) => part?.trim().replace(/\s+/g, " ") ?? "").filter(Boolean);
+  return parts.join(" ") || null;
+}
+function standardKey(ref) {
+  return standardLabel(ref)?.toLowerCase() ?? null;
+}
+function collectStandardKeys(concept) {
+  const sources = [
+    ...concept.sources,
+    ...concept.languages.flatMap((lang) => concept.localization(lang)?.sources ?? [])
+  ];
+  const keys = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (source.type !== "authoritative") continue;
+    const key = standardKey(source.origin?.ref);
+    if (key !== null) keys.add(key);
+  }
+  return [...keys];
+}
+
 // scripts/lib/concept-groups.ts
 function getGroups(conceptYaml) {
   if (conceptYaml.eng && conceptYaml.eng.groups) return conceptYaml.eng.groups;
@@ -1275,7 +1298,26 @@ async function processDataset(dir, register, opts) {
       withPlurality: 0
     }
   };
+  const standards = /* @__PURE__ */ new Map();
   const STATS_PROCESSORS = [
+    function collectStandards(cy, termid) {
+      const concept = {
+        sources: cy._sources || [],
+        languages: Object.keys(cy).filter((lang) => !lang.startsWith("_") && cy[lang] && typeof cy[lang] === "object" && !Array.isArray(cy[lang])),
+        localization: (lang) => cy[lang]
+      };
+      const sources = [
+        ...concept.sources,
+        ...concept.languages.flatMap((lang) => concept.localization(lang).sources || [])
+      ];
+      for (const key of collectStandardKeys(concept)) {
+        if (!standards.has(key)) {
+          const source = sources.find((source2) => source2.type === "authoritative" && standardKey(source2.origin?.ref) === key);
+          standards.set(key, { label: standardLabel(source.origin.ref), conceptIds: [] });
+        }
+        standards.get(key).conceptIds.push(termid);
+      }
+    },
     function collectSources(cy, termid, s) {
       const refs = /* @__PURE__ */ new Set();
       const allSources = [
@@ -1393,12 +1435,17 @@ async function processDataset(dir, register, opts) {
     const chunk = concepts.slice(i, i + CHUNK_SIZE);
     const chunkIndex = Math.floor(i / CHUNK_SIZE);
     const chunkFile = `index-${String(chunkIndex).padStart(4, "0")}.json`;
-    writeJson(path3.join(DATA, register, "chunks", chunkFile), {
+    const chunkData = {
       registerId: register,
       chunkIndex,
       concepts: chunk
-    });
-    chunks.push({ file: chunkFile, count: chunk.length });
+    };
+    const chunkContent = JSON.stringify(chunkData);
+    const chunkPath = path3.join(DATA, register, "chunks", chunkFile);
+    fs2.mkdirSync(path3.dirname(chunkPath), { recursive: true });
+    fs2.writeFileSync(chunkPath, chunkContent);
+    const hash = createHash2("sha256").update(chunkContent).digest("hex").slice(0, 12);
+    chunks.push({ file: chunkFile, count: chunk.length, hash });
   }
   const summary = concepts.map((c) => ({
     id: c.id,
@@ -1490,6 +1537,7 @@ async function processDataset(dir, register, opts) {
     conceptIds: s.conceptIds
   })).sort((a, b) => b.conceptCount - a.conceptCount);
   const totalRelationships = Object.values(stats.relTypeCounts).reduce((a, b) => a + b, 0);
+  writeJson(path3.join(DATA, register, "standards.json"), Object.fromEntries(standards));
   writeJson(path3.join(DATA, register, "stats.json"), {
     sourceCount: sourceStats.length,
     sources: sourceStats,

package/scripts/generate-data.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { createHash } from 'node:crypto';
 import yaml from 'js-yaml';
 import {
   naturalSort,
@@ -15,6 +16,8 @@ import {
   type Concept,
 } from 'glossarist';
 import { loadSiteConfig } from './load-site-config';
+import { collectStandardKeys, standardKey, standardLabel } from '../src/utils/source-standard';
+import type { StandardsIndex } from '../src/adapters/standards-index';
 import { getGroups } from './lib/concept-groups';
 import { consumeDatasetEntities } from './lib/build/non-verbal-consumer';
 import { copyImageAssets } from './lib/build/image-assets';
@@ -740,7 +743,31 @@ async function processDataset(dir, register, opts) {
     },
   };
 
+  const standards = new Map<string, StandardsIndex[string]>();
+
   const STATS_PROCESSORS = [
+    function collectStandards(cy, termid) {
+      // Harmonized metadata uses underscore-prefixed fields; object-valued
+      // language entries include every localization, even if not configured.
+      const concept = {
+        sources: cy._sources || [],
+        languages: Object.keys(cy).filter(lang =>
+          !lang.startsWith('_') && cy[lang] && typeof cy[lang] === 'object' && !Array.isArray(cy[lang])),
+        localization: (lang: string) => cy[lang],
+      };
+      const sources = [
+        ...concept.sources,
+        ...concept.languages.flatMap(lang => concept.localization(lang).sources || []),
+      ];
+      for (const key of collectStandardKeys(concept)) {
+        if (!standards.has(key)) {
+          const source = sources.find(source =>
+            source.type === 'authoritative' && standardKey(source.origin?.ref) === key);
+          standards.set(key, { label: standardLabel(source.origin.ref)!, conceptIds: [] });
+        }
+        standards.get(key)!.conceptIds.push(termid);
+      }
+    },
     function collectSources(cy, termid, s) {
       const refs = new Set();
       const allSources = [
@@ -879,12 +906,17 @@ async function processDataset(dir, register, opts) {
     const chunk = concepts.slice(i, i + CHUNK_SIZE);
     const chunkIndex = Math.floor(i / CHUNK_SIZE);
     const chunkFile = `index-${String(chunkIndex).padStart(4, '0')}.json`;
-    writeJson(path.join(DATA, register, 'chunks', chunkFile), {
+    const chunkData = {
       registerId: register,
       chunkIndex,
       concepts: chunk,
-    });
-    chunks.push({ file: chunkFile, count: chunk.length });
+    };
+    const chunkContent = JSON.stringify(chunkData);
+    const chunkPath = path.join(DATA, register, 'chunks', chunkFile);
+    fs.mkdirSync(path.dirname(chunkPath), { recursive: true });
+    fs.writeFileSync(chunkPath, chunkContent);
+    const hash = createHash('sha256').update(chunkContent).digest('hex').slice(0, 12);
+    chunks.push({ file: chunkFile, count: chunk.length, hash });
   }
 
   const summary = concepts.map(c => ({
@@ -993,6 +1025,8 @@ async function processDataset(dir, register, opts) {
     .sort((a, b) => b.conceptCount - a.conceptCount);
   const totalRelationships = Object.values(stats.relTypeCounts).reduce((a: number, b: number) => a + b, 0);
 
+  writeJson(path.join(DATA, register, 'standards.json'), Object.fromEntries(standards));
+
   writeJson(path.join(DATA, register, 'stats.json'), {
     sourceCount: sourceStats.length,
     sources: sourceStats,

package/src/__tests__/app-footer.test.ts

@@ -35,4 +35,40 @@ describe('AppFooter', () => {
     expect(link).toBeDefined();
     expect(link!.attributes('href')).toBe('https://glossarist.org');
   });
+
+  it('omits hosted by when branding.hostedBy is absent', () => {
+    const wrapper = mountFooter();
+    expect(wrapper.text()).not.toContain('Hosted by');
+  });
+
+  it('renders hosted by with logo when branding.hostedBy is configured', async () => {
+    const inline = document.createElement('script');
+    inline.id = 'site-config-json';
+    inline.type = 'application/json';
+    inline.textContent = JSON.stringify({
+      title: 'Test Site',
+      branding: {
+        hostedBy: {
+          name: 'Enosema Foundation',
+          url: 'https://www.enosema.org',
+          logo: 'https://www.enosema.org/logos/logo-text-white.svg',
+        },
+      },
+    });
+    document.head.appendChild(inline);
+
+    const { useSiteConfig } = await import('../config/use-site-config');
+    await useSiteConfig().loadConfig();
+
+    const wrapper = mountFooter();
+    expect(wrapper.text()).toContain('Hosted by');
+    const link = wrapper.findAll('a').find(a => a.attributes('href') === 'https://www.enosema.org');
+    expect(link).toBeDefined();
+    expect(link!.attributes('href')).toBe('https://www.enosema.org');
+    const img = link!.find('img');
+    expect(img.attributes('src')).toBe('https://www.enosema.org/logos/logo-text-white.svg');
+    expect(img.attributes('alt')).toBe('Enosema Foundation');
+    inline.remove();
+  });
+
 });

package/src/__tests__/app-header.test.ts

@@ -3,6 +3,8 @@ import { mount, flushPromises } from '@vue/test-utils';
 import { createPinia, setActivePinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import AppHeader from '../components/AppHeader.vue';
+import { useUiStore } from '../stores/ui';
+import { locale } from '../i18n';
 import { useVocabularyStore } from '../stores/vocabulary';
 import type { Manifest } from '../adapters/types';
 
@@ -45,6 +47,7 @@ describe('AppHeader', () => {
   let router: Awaited<ReturnType<typeof createTestRouter>>;
 
   beforeEach(async () => {
+    locale.value = 'eng';
     pinia = createPinia();
     setActivePinia(pinia);
     router = await createTestRouter();
@@ -66,10 +69,28 @@ describe('AppHeader', () => {
     expect(wrapper.text()).toContain('Glossarist');
   });
 
-  it('renders search input', () => {
+  it('renders quick search on the home route', () => {
     const wrapper = mountHeader();
-    const input = wrapper.find('input[aria-label="Search concepts"]');
+    const input = wrapper.find('input[aria-label="Quick search"]');
     expect(input.exists()).toBe(true);
+    expect(input.attributes('placeholder')).toBe('Quick search...');
+  });
+
+  it('hides quick search on the search route and restores it elsewhere', async () => {
+    await router.push('/search?q=road');
+    const wrapper = mountHeader();
+    expect(wrapper.find('form').exists()).toBe(false);
+
+    await router.push('/');
+    expect(wrapper.find('form').exists()).toBe(true);
+  });
+
+  it('labels quick search in French', () => {
+    locale.value = 'fra';
+    const wrapper = mountHeader();
+    const input = wrapper.get('input');
+    expect(input.attributes('aria-label')).toBe('Recherche rapide');
+    expect(input.attributes('placeholder')).toBe('Recherche rapide…');
   });
 
   it('renders mobile hamburger button', () => {
@@ -89,13 +110,19 @@ describe('AppHeader', () => {
 
   it('navigates to search on form submit with query', async () => {
     const wrapper = mountHeader();
-    const input = wrapper.find('input[aria-label="Search concepts"]');
-    await input.setValue('road');
+    const input = wrapper.find('input[aria-label="Quick search"]');
+    await input.setValue('  road & rail  ');
     const form = wrapper.find('form');
     await form.trigger('submit');
     await flushPromises();
     expect(router.currentRoute.value.name).toBe('search');
-    expect(router.currentRoute.value.query.q).toBe('road');
+    expect(router.currentRoute.value.query).toEqual({ q: 'road & rail' });
+    expect(router.currentRoute.value.path).toBe('/search');
+    expect(useUiStore().searchQuery).toBe('');
+    expect(wrapper.find('form').exists()).toBe(false);
+
+    await router.push('/');
+    expect(wrapper.get('input').element.value).toBe('');
   });
 
   it('does not navigate on empty search', async () => {