@glossarist/concept-browser 0.7.134 → 0.7.136

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

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { FORMAT_REGISTRY, conceptToTurtle, conceptToSkosJsonLd } from '../utils/concept-formats';
-import { Concept } from 'glossarist';
-
-function makeConcept(overrides: Record<string, unknown> = {}): Concept {
-  return Concept.fromJSON({
-    id: '1',
-    uri: 'https://glossarist.org/test/concept/1',
-    localizations: {
-      eng: {
-        language_code: 'eng',
-        entry_status: 'valid',
-        terms: [
-          { type: 'expression', designation: 'test term', normative_status: 'preferred' },
-          { type: 'expression', designation: 'alt term', normative_status: 'admitted' },
-        ],
-        definition: [{ content: 'a definition' }],
-        notes: [{ content: 'a note' }],
-      },
-      deu: {
-        language_code: 'deu',
-        entry_status: 'valid',
-        terms: [
-          { type: 'expression', designation: 'Testbegriff', normative_status: 'preferred' },
-        ],
-        definition: [{ 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 = 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(Concept.fromJSON({}));
-    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 = 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();
-  });
-});

package/src/utils/concept-formats.ts

@@ -1,123 +0,0 @@
-import type { Concept } from 'glossarist';
-
-export interface FormatDescriptor {
-  extension: string;
-  label: string;
-  mediaType: string;
-}
-
-export const FORMAT_REGISTRY: Record<string, FormatDescriptor> = {
-  ttl: { extension: 'ttl', label: 'Turtle RDF', mediaType: 'text/turtle' },
-  jsonld: { extension: 'jsonld', label: 'JSON-LD', mediaType: 'application/ld+json' },
-  tbx: { extension: 'tbx', label: 'TBX-XML', mediaType: 'application/xml' },
-  yaml: { extension: 'yaml', label: 'YAML', mediaType: 'text/yaml' },
-};
-
-function getLocalizedData(concept: Concept) {
-  const result: Record<string, {
-    prefLabels: string[];
-    altLabels: string[];
-    definitions: string[];
-    notes: string[];
-  }> = {};
-
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    if (!lc) continue;
-
-    const prefLabels = lc.terms
-      .filter(d => d.normativeStatus === 'preferred' && d.designation)
-      .map(d => d.designation);
-    const altLabels = lc.terms
-      .filter(d => d.normativeStatus !== 'preferred' && d.designation)
-      .map(d => d.designation);
-    const definitions = lc.definitions
-      .map(d => d.content || '')
-      .filter(Boolean);
-    const notes = lc.notes
-      .map(d => d.content || '')
-      .filter(Boolean);
-
-    if (prefLabels.length || definitions.length) {
-      result[lang] = { prefLabels, altLabels, definitions, notes };
-    }
-  }
-
-  return result;
-}
-
-function escapeTurtle(s: string): string {
-  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
-}
-
-export function conceptToTurtle(concept: Concept): string {
-  const uri = concept.uri || '';
-  const id = concept.id;
-  const data = getLocalizedData(concept);
-
-  const lines: string[] = [
-    '@prefix skos: <http://www.w3.org/2004/02/skos/core#> .',
-    '@prefix dcterms: <http://purl.org/dc/terms/> .',
-    '',
-  ];
-
-  const props: string[] = ['a skos:Concept'];
-  props.push(`  skos:notation "${escapeTurtle(id)}"`);
-
-  for (const [lang, d] of Object.entries(data)) {
-    for (const label of d.prefLabels) {
-      props.push(`  skos:prefLabel "${escapeTurtle(label)}"@${lang}`);
-    }
-    for (const label of d.altLabels) {
-      props.push(`  skos:altLabel "${escapeTurtle(label)}"@${lang}`);
-    }
-    for (const def of d.definitions) {
-      props.push(`  skos:definition "${escapeTurtle(def)}"@${lang}`);
-    }
-    for (const note of d.notes) {
-      props.push(`  skos:scopeNote "${escapeTurtle(note)}"@${lang}`);
-    }
-  }
-
-  lines.push(`<${uri}>`);
-  lines.push(props.join(' ;\n'));
-  lines.push(' .');
-
-  return lines.join('\n');
-}
-
-export function conceptToSkosJsonLd(concept: Concept): string {
-  const uri = concept.uri || '';
-  const id = concept.id;
-  const data = getLocalizedData(concept);
-
-  const doc: Record<string, any> = {
-    '@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: Record<string, string> = {};
-  const altLabels: Record<string, string> = {};
-  const definitions: Record<string, string> = {};
-  const scopeNotes: Record<string, string> = {};
-
-  for (const [lang, d] of Object.entries(data)) {
-    if (d.prefLabels[0]) prefLabels[lang] = d.prefLabels[0];
-    if (d.altLabels[0]) altLabels[lang] = d.altLabels[0];
-    if (d.definitions[0]) definitions[lang] = d.definitions[0];
-    if (d.notes[0]) scopeNotes[lang] = d.notes[0];
-  }
-
-  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);
-}