@glossarist/concept-browser 0.7.51 → 0.7.53

package/src/__tests__/concept-rdf/group-emitter.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitGroupGraph } from '../../components/concept-rdf/group-emitter';
+
+const DCAT = 'http://www.w3.org/ns/dcat#';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('emitGroupGraph — lineage → dcat:DatasetSeries', () => {
+  it('types lineage group as dcat:DatasetSeries', () => {
+    const graph = emitGroupGraph({
+      groupId: 'viml', groupIri: 'https://x.test/group/viml',
+      kind: 'lineage', title: 'VIML',
+      memberIris: ['https://x.test/dataset/viml-2022'],
+    });
+    const store = parse(writeTurtle(graph));
+    const types = store.getObjects('https://x.test/group/viml', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${DCAT}DatasetSeries`);
+  });
+
+  it('emits dcat:hasVersion for each member', () => {
+    const graph = emitGroupGraph({
+      groupId: 'viml', groupIri: 'https://x.test/group/viml',
+      kind: 'lineage', title: 'VIML',
+      memberIris: ['https://x.test/dataset/viml-2013', 'https://x.test/dataset/viml-2022'],
+    });
+    const store = parse(writeTurtle(graph));
+    const versions = store.getObjects('https://x.test/group/viml', `${DCAT}hasVersion`, null).map(q => q.value);
+    expect(versions).toContain('https://x.test/dataset/viml-2013');
+    expect(versions).toContain('https://x.test/dataset/viml-2022');
+  });
+
+  it('emits gloss:hasCurrentVersion for the current member', () => {
+    const graph = emitGroupGraph({
+      groupId: 'viml', groupIri: 'https://x.test/group/viml',
+      kind: 'lineage', title: 'VIML',
+      memberIris: ['https://x.test/dataset/viml-2022'],
+      currentMemberIri: 'https://x.test/dataset/viml-2022',
+    });
+    const store = parse(writeTurtle(graph));
+    const current = store.getObjects('https://x.test/group/viml', 'https://www.glossarist.org/ontologies/hasCurrentVersion', null).map(q => q.value);
+    expect(current).toContain('https://x.test/dataset/viml-2022');
+  });
+});
+
+describe('emitGroupGraph — topic/family/collection → dcat:Catalog', () => {
+  it('types topic group as dcat:Catalog', () => {
+    const graph = emitGroupGraph({
+      groupId: 'its', groupIri: 'https://x.test/group/its',
+      kind: 'topic', title: 'ITS Standards',
+      memberIris: ['https://x.test/dataset/iso-14817'],
+    });
+    const store = parse(writeTurtle(graph));
+    const types = store.getObjects('https://x.test/group/its', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${DCAT}Catalog`);
+  });
+
+  it('emits dcat:dataset for each member', () => {
+    const graph = emitGroupGraph({
+      groupId: 'its', groupIri: 'https://x.test/group/its',
+      kind: 'topic', title: 'ITS',
+      memberIris: ['https://x.test/dataset/a', 'https://x.test/dataset/b'],
+    });
+    const store = parse(writeTurtle(graph));
+    const datasets = store.getObjects('https://x.test/group/its', `${DCAT}dataset`, null).map(q => q.value);
+    expect(datasets).toContain('https://x.test/dataset/a');
+    expect(datasets).toContain('https://x.test/dataset/b');
+  });
+});
+
+describe('emitGroupGraph — default kind → no emission', () => {
+  it('produces an empty graph for default kind', () => {
+    const graph = emitGroupGraph({
+      groupId: 'misc', groupIri: 'https://x.test/group/misc',
+      kind: 'default', title: 'Misc',
+      memberIris: [],
+    });
+    expect(Array.from(graph.resources()).length).toBe(0);
+  });
+});
+
+describe('emitGroupGraph — metadata', () => {
+  it('emits title, description, identifier, subject, keywords', () => {
+    const graph = emitGroupGraph({
+      groupId: 'viml', groupIri: 'https://x.test/group/viml',
+      kind: 'lineage', title: 'VIML',
+      description: 'Legal metrology vocabulary',
+      subject: 'legal metrology',
+      keywords: ['metrology', 'legal'],
+      memberIris: [],
+    });
+    const store = parse(writeTurtle(graph));
+    expect(store.getObjects('https://x.test/group/viml', `${DCTERMS}title`, null).map(q => q.value)).toContain('VIML');
+    expect(store.getObjects('https://x.test/group/viml', `${DCTERMS}description`, null).map(q => q.value)).toContain('Legal metrology vocabulary');
+    expect(store.getObjects('https://x.test/group/viml', `${DCTERMS}identifier`, null).map(q => q.value)).toContain('viml');
+    expect(store.getObjects('https://x.test/group/viml', `${DCTERMS}subject`, null).map(q => q.value)).toContain('legal metrology');
+    const keywords = store.getObjects('https://x.test/group/viml', `${DCAT}keyword`, null).map(q => q.value);
+    expect(keywords).toContain('metrology');
+    expect(keywords).toContain('legal');
+  });
+});

package/src/__tests__/concept-rdf/image-variant-emitter.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import {
+  emitImageVariantGraph,
+  imageVariantIri,
+} from '../../components/concept-rdf/image-variant-emitter';
+
+const FOAF = 'http://xmlns.com/foaf/0.1/';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const DCAT = 'http://www.w3.org/ns/dcat#';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('WS K2 — image binary references', () => {
+  it('types each image variant as foaf:Image', () => {
+    const graph = emitImageVariantGraph({
+      registerId: 'iso-geodetic',
+      figureId: 'fig_1',
+      lang: 'eng',
+      format: 'svg',
+      downloadUrl: 'https://glossarist.org/data/iso-geodetic/images/fig_1.svg',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = imageVariantIri({
+      registerId: 'iso-geodetic',
+      figureId: 'fig_1',
+      lang: 'eng',
+      format: 'svg',
+      downloadUrl: 'x',
+    });
+    const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${FOAF}Image`);
+  });
+
+  it('emits dcterms:format with the correct MIME type', () => {
+    const cases: Array<{ format: 'svg' | 'png' | 'webp' | 'jpg' | 'gif'; mime: string }> = [
+      { format: 'svg', mime: 'image/svg+xml' },
+      { format: 'png', mime: 'image/png' },
+      { format: 'webp', mime: 'image/webp' },
+      { format: 'jpg', mime: 'image/jpeg' },
+      { format: 'gif', mime: 'image/gif' },
+    ];
+    for (const { format, mime } of cases) {
+      const graph = emitImageVariantGraph({
+        registerId: 'r',
+        figureId: 'f',
+        format,
+        downloadUrl: 'x',
+      });
+      const store = parse(writeTurtle(graph));
+      const iri = imageVariantIri({ registerId: 'r', figureId: 'f', format, downloadUrl: 'x' });
+      const formats = store.getObjects(iri, `${DCTERMS}format`, null).map(q => q.value);
+      expect(formats).toContain(mime);
+    }
+  });
+
+  it('emits dcterms:language when lang is provided', () => {
+    const graph = emitImageVariantGraph({
+      registerId: 'r',
+      figureId: 'f',
+      lang: 'fra',
+      format: 'svg',
+      downloadUrl: 'x',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = imageVariantIri({ registerId: 'r', figureId: 'f', lang: 'fra', format: 'svg', downloadUrl: 'x' });
+    const langs = store.getObjects(iri, `${DCTERMS}language`, null).map(q => q.value);
+    expect(langs).toContain('fra');
+  });
+
+  it('omits dcterms:language when lang is absent', () => {
+    const graph = emitImageVariantGraph({
+      registerId: 'r',
+      figureId: 'f',
+      format: 'svg',
+      downloadUrl: 'x',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = imageVariantIri({ registerId: 'r', figureId: 'f', format: 'svg', downloadUrl: 'x' });
+    const langs = store.getObjects(iri, `${DCTERMS}language`, null);
+    expect(langs.length).toBe(0);
+  });
+
+  it('emits dcat:byteSize as xsd:integer when byteSize is provided', () => {
+    const graph = emitImageVariantGraph({
+      registerId: 'r',
+      figureId: 'f',
+      format: 'png',
+      byteSize: 12345,
+      downloadUrl: 'x',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = imageVariantIri({ registerId: 'r', figureId: 'f', format: 'png', byteSize: 0, downloadUrl: 'x' });
+    const sizes = store.getObjects(iri, `${DCAT}byteSize`, null);
+    expect(sizes.length).toBe(1);
+    expect((sizes[0] as any).value).toBe('12345');
+    expect((sizes[0] as any).datatype.value).toBe('http://www.w3.org/2001/XMLSchema#integer');
+  });
+
+  it('emits dcat:downloadURL pointing at the binary asset', () => {
+    const graph = emitImageVariantGraph({
+      registerId: 'iso-geodetic',
+      figureId: 'fig_1',
+      lang: 'eng',
+      format: 'svg',
+      downloadUrl: 'https://glossarist.org/data/iso-geodetic/images/fig_1.svg',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = imageVariantIri({
+      registerId: 'iso-geodetic',
+      figureId: 'fig_1',
+      lang: 'eng',
+      format: 'svg',
+      downloadUrl: 'x',
+    });
+    const urls = store.getObjects(iri, `${DCAT}downloadURL`, null).map(q => q.value);
+    expect(urls).toContain('https://glossarist.org/data/iso-geodetic/images/fig_1.svg');
+  });
+
+  it('produces distinct IRIs per (figure, lang, format) combination', () => {
+    const iri1 = imageVariantIri({ registerId: 'r', figureId: 'f', lang: 'eng', format: 'svg', downloadUrl: 'x' });
+    const iri2 = imageVariantIri({ registerId: 'r', figureId: 'f', lang: 'eng', format: 'png', downloadUrl: 'x' });
+    const iri3 = imageVariantIri({ registerId: 'r', figureId: 'f', lang: 'fra', format: 'svg', downloadUrl: 'x' });
+    expect(iri1).not.toBe(iri2);
+    expect(iri1).not.toBe(iri3);
+    expect(iri2).not.toBe(iri3);
+  });
+});

package/src/__tests__/concept-rdf/jsonld-writer.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { writeJsonLd } from '../../components/concept-rdf/jsonld-writer';
+import { RdfGraph, lit, iri, blank, triple } from '../../components/concept-rdf/rdf-graph';
+
+describe('writeJsonLd', () => {
+  it('produces a JSON-LD document with @context and @graph', () => {
+    const g = new RdfGraph();
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@context']).toBeDefined();
+    expect(Array.isArray(doc['@graph'])).toBe(true);
+    expect(doc['@context'].gloss).toBe('https://www.glossarist.org/ontologies/');
+    expect(doc['@context'].skosxl).toBe('http://www.w3.org/2008/05/skos-xl#');
+  });
+
+  it('emits @id and @type for each resource', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: ['gloss:Concept', 'skos:Concept'] });
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    const node = doc['@graph'][0];
+    expect(node['@id']).toBe('https://ex/c');
+    expect(node['@type']).toEqual(['gloss:Concept', 'skos:Concept']);
+  });
+
+  it('emits plain string literals for untagged values', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:identifier', 'X');
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:identifier']).toBe('X');
+  });
+
+  it('emits language-tagged literals as @value/@language objects', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('skos:prefLabel', 'term', { lang: 'eng' });
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['skos:prefLabel']).toEqual({ '@value': 'term', '@language': 'eng' });
+  });
+
+  it('emits datatyped literals as @value/@type objects', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:value', '42', { datatype: 'xsd:integer' });
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:value']).toEqual({ '@value': '42', '@type': 'xsd:integer' });
+  });
+
+  it('emits IRI objects as @id references', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .iri('gloss:related', 'https://ex/other');
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:related']).toEqual({ '@id': 'https://ex/other' });
+  });
+
+  it('emits single object for predicates with one value', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:note', 'one');
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:note']).toBe('one');
+  });
+
+  it('emits arrays for predicates with multiple values', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:note', 'one')
+      .literal('gloss:note', 'two');
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:note']).toEqual(['one', 'two']);
+  });
+
+  it('serializes blank nodes as nested objects', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .blank('gloss:hasSource', [
+        triple('rdf:value', lit('ISO 123')),
+        triple('dcterms:title', lit('Standard')),
+      ]);
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(doc['@graph'][0]['gloss:hasSource']).toEqual({
+      'rdf:value': 'ISO 123',
+      'dcterms:title': 'Standard',
+    });
+  });
+
+  it('serializes multiple blank nodes for the same predicate as an array', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .blank('gloss:hasSource', [triple('rdf:value', lit('A'))])
+      .blank('gloss:hasSource', [triple('rdf:value', lit('B'))]);
+    const out = writeJsonLd(g);
+    const doc = JSON.parse(out);
+    expect(Array.isArray(doc['@graph'][0]['gloss:hasSource'])).toBe(true);
+    expect(doc['@graph'][0]['gloss:hasSource']).toEqual([
+      { 'rdf:value': 'A' },
+      { 'rdf:value': 'B' },
+    ]);
+  });
+});

package/src/__tests__/concept-rdf/nonverbal-rep.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { Concept } from 'glossarist';
+
+const G = 'https://www.glossarist.org/ontologies/';
+const SKOSXL = 'http://www.w3.org/2008/05/skos-xl#';
+const SKOS = 'http://www.w3.org/2004/02/skos/core#';
+const PROV = 'http://www.w3.org/ns/prov#';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const BASE = 'https://glossarist.org/fixtures/k4';
+
+function emitAndParse(concept: Concept) {
+  const { graph } = emitConceptGraph(concept, concept.uri ?? '');
+  return { graph, store: parse(writeTurtle(graph)) };
+}
+
+describe('WS K4 — NVRs as first-class URIs', () => {
+  it('emits an NVR URI when the NVR has a caption (prefLabel material)', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.1', uri: `${BASE}/k4.1`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'K4 concept', normative_status: 'preferred' }],
+          definition: [{ content: 'Concept with a referenced NVR.' }],
+          non_verbal_rep: [
+            { type: 'expression', caption: 'Diagram label', images: [{ src: 'https://glossarist.org/figs/1.svg' }] },
+          ],
+        },
+      },
+    });
+
+    const { graph, store } = emitAndParse(concept);
+    const nvrUri = `${BASE}/k4.1/nvr/1_svg`;
+    expect(graph.get(nvrUri)).toBeDefined();
+
+    const lcUri = `${BASE}/k4.1/eng`;
+    const links = store.getObjects(lcUri, `${G}hasNonVerbalRepresentation`, null).map(q => q.value);
+    expect(links).toContain(nvrUri);
+
+    const nvrTypes = store.getObjects(nvrUri, RDF_TYPE, null).map(q => q.value);
+    expect(nvrTypes).toContain(`${G}NonVerbalRep`);
+    expect(nvrTypes).toContain(`${G}Expression`);
+    expect(nvrTypes).toContain(`${SKOS}Concept`);
+
+    const prefLabelBlanks = store.getObjects(nvrUri, `${SKOSXL}prefLabel`, null);
+    expect(prefLabelBlanks.length).toBe(1);
+    const literalForms = store.getObjects(prefLabelBlanks[0], `${SKOSXL}literalForm`, null);
+    expect(literalForms.length).toBe(1);
+    expect((literalForms[0] as any).value).toBe('Diagram label');
+    expect((literalForms[0] as any).language).toBe('eng');
+  });
+
+  it('emits gloss:image as xsd:anyURI on the NVR', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.2', uri: `${BASE}/k4.2`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'K4 with image', normative_status: 'preferred' }],
+          definition: [{ content: 'Has an NVR with image.' }],
+          non_verbal_rep: [
+            { type: 'expression', caption: 'Fig', images: [{ src: 'https://x.test/fig.svg' }] },
+          ],
+        },
+      },
+    });
+    const { store } = emitAndParse(concept);
+    const nvrUri = `${BASE}/k4.2/nvr/fig_svg`;
+    const images = store.getObjects(nvrUri, `${G}image`, null);
+    expect(images.length).toBe(1);
+    expect((images[0] as any).value).toBe('https://x.test/fig.svg');
+    expect((images[0] as any).datatype.value).toBe(`${XSD}anyURI`);
+  });
+
+  it('emits prov:wasDerivedFrom from sources[0].origin.link', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.3', uri: `${BASE}/k4.3`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'K4 with source', normative_status: 'preferred' }],
+          definition: [{ content: 'Has an NVR with source.' }],
+          non_verbal_rep: [
+            {
+              type: 'expression', caption: 'Fig',
+              sources: [{ status: 'identical', type: 'authoritative', origin: { ref: { source: 'ISO', id: 'X' }, link: 'https://x.test/source' } }],
+            },
+          ],
+        },
+      },
+    });
+    const { store } = emitAndParse(concept);
+    const derived = store.getObjects(`${BASE}/k4.3/nvr/Fig`, `${PROV}wasDerivedFrom`, null).map(q => q.value);
+    expect(derived).toContain('https://x.test/source');
+  });
+
+  it('falls back to gloss:hasNonVerbalRep blank-node emission when NVR has no caption and no image', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.4', uri: `${BASE}/k4.4`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'K4 fallback', normative_status: 'preferred' }],
+          definition: [{ content: 'Has an NVR with no useful content.' }],
+          non_verbal_rep: [{ type: 'expression' }],
+        },
+      },
+    });
+    const { store } = emitAndParse(concept);
+    const lcUri = `${BASE}/k4.4/eng`;
+    const uriLinks = store.getObjects(lcUri, `${G}hasNonVerbalRepresentation`, null);
+    expect(uriLinks.length).toBe(0);
+    const blankLinks = store.getObjects(lcUri, `${G}hasNonVerbalRep`, null);
+    expect(blankLinks.length).toBe(1);
+  });
+
+  it('produces NVR URIs keyed by index when multiple NVRs are present', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.5', uri: `${BASE}/k4.5`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'K4 multiple', normative_status: 'preferred' }],
+          definition: [{ content: 'Has multiple NVRs.' }],
+          non_verbal_rep: [
+            { type: 'expression', caption: 'One', images: [{ src: 'https://x.test/1.svg' }] },
+            { type: 'expression', caption: 'Two', images: [{ src: 'https://x.test/2.svg' }] },
+            { type: 'expression', caption: 'Three', images: [{ src: 'https://x.test/3.svg' }] },
+          ],
+        },
+      },
+    });
+    const { store } = emitAndParse(concept);
+    const lcUri = `${BASE}/k4.5/eng`;
+    const links = store.getObjects(lcUri, `${G}hasNonVerbalRepresentation`, null).map(q => q.value);
+    expect(links).toContain(`${BASE}/k4.5/nvr/1_svg`);
+    expect(links).toContain(`${BASE}/k4.5/nvr/2_svg`);
+    expect(links).toContain(`${BASE}/k4.5/nvr/3_svg`);
+  });
+});
+
+describe('WS K4 — URI NVR conforms to canonical NonVerbalRep shape', () => {
+  it('emits NVR resources that satisfy gloss:NonVerbalRepShape (skosxl:prefLabel min 1)', () => {
+    const concept = Concept.fromJSON({
+      id: 'k4.6', uri: `${BASE}/k4.6`, status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'shape-conformant', normative_status: 'preferred' }],
+          definition: [{ content: 'NVR conforms to shape.' }],
+          non_verbal_rep: [
+            { type: 'expression', caption: 'Label', images: [{ src: 'https://x.test/fig.svg' }] },
+          ],
+        },
+      },
+    });
+    const { store } = emitAndParse(concept);
+    const nvrUri = `${BASE}/k4.6/nvr/fig_svg`;
+    const prefLabels = store.getObjects(nvrUri, `${SKOSXL}prefLabel`, null);
+    expect(prefLabels.length).toBeGreaterThanOrEqual(1);
+    const nvrTypes = store.getObjects(nvrUri, RDF_TYPE, null).map(q => q.value);
+    expect(nvrTypes).toContain(`${G}NonVerbalRep`);
+    expect(nvrTypes).toContain(`${SKOS}Concept`);
+  });
+});