@glossarist/concept-browser 0.7.34 → 0.7.37

package/src/__tests__/graph-data-source.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi } from 'vitest';
+import { GraphDataSource } from '../adapters/GraphDataSource';
+import type { DatasetAdapter } from '../adapters/DatasetAdapter';
+import type { Concept, RelatedConcept } from 'glossarist';
+import { conceptFromJson } from '../adapters/model-bridge';
+
+function makeMinimalConcept(overrides: Record<string, unknown> = {}): Concept {
+  return conceptFromJson({
+    '@type': 'skos:Concept',
+    '@id': 'https://glossarist.org/test/concept/1',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        'gl:designation': [{ '@type': 'Expression', 'gl:term': 'test term' }],
+        'gl:definition': [{ 'gl:content': 'test definition' }],
+      },
+    },
+    ...overrides,
+  });
+}
+
+function makeAdapterStub(manifest?: Record<string, unknown>): DatasetAdapter {
+  return {
+    registerId: 'test',
+    dataUrl: '/data/test',
+    manifest: manifest ? { uriBase: 'https://glossarist.org', ...manifest } as any : { uriBase: 'https://glossarist.org' } as any,
+    urnMap: new Map([['urn:iso:std:iso:10241', 'test']]),
+  } as unknown as DatasetAdapter;
+}
+
+describe('GraphDataSource', () => {
+  describe('resolveRefTarget', () => {
+    it('returns empty string when ref is null', async () => {
+      const { GraphDataSource } = await import('../adapters/GraphDataSource');
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept();
+      // concept.relatedConcepts is empty, so extractEdges returns []
+      const edges = ds.extractEdges(concept);
+      expect(edges).toEqual([]);
+    });
+  });
+
+  describe('extractEdges', () => {
+    it('extracts concept-level related concept edges', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept({
+        'gl:related': [{
+          'gl:relationshipType': 'references',
+          'gl:ref': { 'gl:source': 'urn:iso:std:iso:10241', 'gl:id': '2.1' },
+        }],
+      });
+      const edges = ds.extractEdges(concept);
+      expect(edges.length).toBeGreaterThan(0);
+      expect(edges[0].type).toBe('references');
+      expect(edges[0].source).toContain('/concept/1');
+    });
+
+    it('extracts localization-level related concept edges', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept({
+        'gl:localizedConcept': {
+          eng: {
+            'gl:languageCode': 'eng',
+            'gl:entryStatus': 'valid',
+            'gl:designation': [{ '@type': 'Expression', 'gl:term': 'test term' }],
+            'gl:references': [{
+              'gl:relationshipType': 'related',
+              'gl:ref': { 'gl:source': 'urn:iso:std:iso:10241', 'gl:id': '3.1' },
+            }],
+          },
+        },
+      });
+      const edges = ds.extractEdges(concept);
+      expect(edges.length).toBeGreaterThan(0);
+      const relatedEdge = edges.find(e => e.type === 'related');
+      expect(relatedEdge).toBeDefined();
+      expect(relatedEdge!.lang).toBe('eng');
+    });
+
+    it('skips self-referencing edges', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept({
+        'gl:related': [{
+          'gl:relationshipType': 'references',
+          'gl:ref': { 'gl:source': 'https://glossarist.org', 'gl:id': '1' },
+          '@id': 'https://glossarist.org/test/concept/1',
+        }],
+      });
+      const edges = ds.extractEdges(concept);
+      // Self-reference should be filtered out
+      expect(edges).toEqual([]);
+    });
+  });
+
+  describe('extractDomainEdges', () => {
+    it('creates domain edges from localized domains', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept({
+        'gl:localizedConcept': {
+          eng: {
+            'gl:languageCode': 'eng',
+            'gl:entryStatus': 'valid',
+            'gl:designation': [{ '@type': 'Expression', 'gl:term': 'test term' }],
+            'gl:domain': 'Metrology',
+          },
+          fra: {
+            'gl:languageCode': 'fra',
+            'gl:entryStatus': 'valid',
+            'gl:designation': [{ '@type': 'Expression', 'gl:term': 'test terme' }],
+            'gl:domain': 'Métrologie',
+          },
+        },
+      });
+      const edges = ds.extractDomainEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges[0].type).toBe('domain');
+      expect(edges[0].label).toBe('Metrology');
+      expect(edges[0].lang).toBe('eng');
+      expect(edges[1].label).toBe('Métrologie');
+      expect(edges[1].lang).toBe('fra');
+    });
+
+    it('returns empty for concepts without domains', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      const concept = makeMinimalConcept();
+      const edges = ds.extractDomainEdges(concept);
+      expect(edges).toEqual([]);
+    });
+  });
+
+  describe('getSectionTree', () => {
+    it('returns empty when manifest has no sections', () => {
+      const ds = new GraphDataSource(makeAdapterStub());
+      expect(ds.getSectionTree()).toEqual([]);
+    });
+
+    it('maps manifest sections to section tree', () => {
+      const ds = new GraphDataSource(makeAdapterStub({
+        sections: [
+          { id: '1', names: { eng: 'Section 1' }, children: [
+            { id: '1.1', names: { eng: 'Section 1.1' } },
+          ]},
+        ],
+      }));
+      const tree = ds.getSectionTree();
+      expect(tree.length).toBe(1);
+      expect(tree[0].id).toBe('1');
+      expect(tree[0].names.eng).toBe('Section 1');
+      expect(tree[0].children?.length).toBe(1);
+      expect(tree[0].children![0].id).toBe('1.1');
+    });
+  });
+});

package/src/__tests__/model-bridge-bridges.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson, getRelatedSourceId, getRelatedCitation } from '../adapters/model-bridge';
+
+describe('model-bridge — mapRefFromJsonLd', () => {
+  it('maps string ref to { source }', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:source': [{
+            '@type': 'gl:ConceptSource',
+            'gl:sourceType': 'authoritative',
+            'gl:origin': {
+              '@type': 'gl:Citation',
+              'gl:ref': 'ISO 9000:2015',
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const sources = concept.localization('eng')!.sources;
+    expect(sources[0].origin!.ref!.source).toBe('ISO 9000:2015');
+  });
+
+  it('prefers gl:-prefixed keys over unprefixed keys', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:source': [{
+            '@type': 'gl:ConceptSource',
+            'gl:origin': {
+              '@type': 'gl:Citation',
+              'gl:ref': {
+                'gl:source': 'gl-source',
+                'source': 'plain-source',
+                'gl:id': 'gl-id',
+                'id': 'plain-id',
+              },
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const sources = concept.localization('eng')!.sources;
+    expect(sources[0].origin!.ref!.source).toBe('gl-source');
+    expect(sources[0].origin!.ref!.id).toBe('gl-id');
+  });
+});
+
+describe('model-bridge — locality mapping round-trip', () => {
+  it('maps gl:referenceFrom to Locality instance with correct getters', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:source': [{
+            '@type': 'gl:ConceptSource',
+            'gl:origin': {
+              '@type': 'gl:Citation',
+              'gl:ref': { 'gl:source': 'ISO 9000' },
+              'gl:locality': {
+                'gl:localityType': 'clause',
+                'gl:referenceFrom': '3.1',
+                'gl:referenceTo': '3.5',
+              },
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const origin = concept.localization('eng')!.sources[0].origin!;
+    const loc = origin.locality!;
+    // Locality model uses camelCase getters, toJSON() produces snake_case
+    expect(loc.type).toBe('clause');
+    expect(loc.referenceFrom).toBe('3.1');
+    expect(loc.referenceTo).toBe('3.5');
+    // Verify serialization is snake_case
+    const json = loc.toJSON();
+    expect(json.reference_from).toBe('3.1');
+    expect(json.reference_to).toBe('3.5');
+  });
+});
+
+describe('model-bridge — citation bridge round-trip', () => {
+  it('preserves sourceId and citation through JSON-LD round-trip', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:references': [{
+            '@id': 'cite:vim-2.2',
+            'gl:term': 'entity',
+            'gl:sourceId': 'vim-2.2',
+            'gl:citation': {
+              'gl:ref': {
+                '@type': 'gl:Ref',
+                'gl:source': 'OIML V2-200:2012',
+                'gl:id': '2.2',
+              },
+              'gl:locality': {
+                'gl:localityType': 'definition',
+                'gl:referenceFrom': '2.2',
+              },
+              'gl:link': 'https://example.com/vim',
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    const rc = lc.related[0];
+
+    // All fields preserved through the bridge
+    expect(rc.content).toBe('entity');
+    expect(getRelatedSourceId(rc)).toBe('vim-2.2');
+
+    const citation = getRelatedCitation(rc)!;
+    expect((citation.ref as any).source).toBe('OIML V2-200:2012');
+    expect((citation.ref as any).id).toBe('2.2');
+    // Citation locality is stored as raw dict (snake_case from mapLocalityFromJsonLd)
+    expect((citation.locality as any).type).toBe('definition');
+    expect((citation.locality as any).reference_from).toBe('2.2');
+    expect(citation.link).toBe('https://example.com/vim');
+  });
+});

package/src/__tests__/model-bridge-citation.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson, getRelatedSourceId, getRelatedCitation } from '../adapters/model-bridge';
+
+describe('model-bridge — source id mapping', () => {
+  it('maps gl:id from JSON-LD ConceptSource', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:source': [{
+            '@type': 'gl:ConceptSource',
+            'gl:id': 'iso-10303-2-def',
+            'gl:sourceType': 'authoritative',
+            'gl:origin': {
+              '@type': 'gl:Citation',
+              'gl:ref': {
+                '@type': 'gl:Ref',
+                'gl:source': 'ISO 10303-2',
+                'gl:id': '3.1.1',
+              },
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const sources = concept.localization('eng')!.sources;
+    expect(sources).toHaveLength(1);
+    expect((sources[0] as any).id).toBe('iso-10303-2-def');
+    expect(sources[0].origin!.ref!.source).toBe('ISO 10303-2');
+    expect(sources[0].origin!.ref!.id).toBe('3.1.1');
+  });
+});
+
+describe('model-bridge — reference citation mapping via WeakMap bridges', () => {
+  it('maps gl:sourceId from JSON-LD reference', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:references': [{
+            '@id': 'cite:iso-10303-2-def',
+            'gl:term': 'entity data type',
+            'gl:sourceId': 'iso-10303-2-def',
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    const related = lc.related;
+    expect(related).toHaveLength(1);
+    expect(related[0].content).toBe('entity data type');
+    expect(getRelatedSourceId(related[0])).toBe('iso-10303-2-def');
+  });
+
+  it('maps gl:citation from JSON-LD reference', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:references': [{
+            '@id': 'cite:vim-def',
+            'gl:term': 'entity',
+            'gl:sourceId': 'vim-def',
+            'gl:citation': {
+              'gl:ref': {
+                '@type': 'gl:Ref',
+                'gl:source': 'OIML V2-200:2012',
+                'gl:id': '2.2',
+              },
+              'gl:locality': {
+                'gl:localityType': 'clause',
+                'gl:referenceFrom': '2.2',
+              },
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    const related = lc.related;
+    expect(related).toHaveLength(1);
+
+    const citation = getRelatedCitation(related[0]);
+    expect(citation).toBeDefined();
+    expect((citation!.ref as any).source).toBe('OIML V2-200:2012');
+    expect((citation!.ref as any).id).toBe('2.2');
+    expect((citation!.locality as any).type).toBe('clause');
+    expect((citation!.locality as any).reference_from).toBe('2.2');
+  });
+
+  it('maps gl:citation with link', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:references': [{
+            '@id': 'cite:iso-9000',
+            'gl:term': 'ISO 9000',
+            'gl:sourceId': 'iso-9000',
+            'gl:citation': {
+              'gl:ref': {
+                '@type': 'gl:Ref',
+                'gl:source': 'ISO 9000:2015',
+              },
+              'gl:link': 'https://iso.org/standard/62085.html',
+            },
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    const related = lc.related;
+    const citation = getRelatedCitation(related[0]);
+    expect(citation!.link).toBe('https://iso.org/standard/62085.html');
+  });
+
+  it('returns null for RelatedConcept without bridged fields', () => {
+    const doc = {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.com/reg/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:references': [{
+            '@id': 'https://example.com/reg/concept/2',
+            'gl:term': 'other concept',
+          }],
+        },
+      },
+    };
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    expect(getRelatedSourceId(lc.related[0])).toBeNull();
+    expect(getRelatedCitation(lc.related[0])).toBeNull();
+  });
+});

package/src/__tests__/reference-resolver-cite.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createResolverPair } from './test-helpers';
+
+describe('ReferenceResolver — resolveCite edge cases', () => {
+  let resolver: ReturnType<typeof createResolverPair>['resolver'];
+  let uriRouter: ReturnType<typeof createResolverPair>['uriRouter'];
+
+  beforeEach(() => {
+    const pair = createResolverPair();
+    resolver = pair.resolver;
+    uriRouter = pair.uriRouter;
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+  });
+
+  it('handles citation with camelCase locality (backward compat)', () => {
+    const result = resolver.resolveCite({
+      ref: { source: 'VIM' },
+      locality: { referenceFrom: '2.2' } as any,
+    });
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved).toEqual({ registerId: 'vim-2012', conceptId: '2.2' });
+  });
+
+  it('handles citation with snake_case locality', () => {
+    const result = resolver.resolveCite({
+      ref: { source: 'VIM' },
+      locality: { reference_from: '2.2' },
+    });
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved).toEqual({ registerId: 'vim-2012', conceptId: '2.2' });
+  });
+
+  it('resolves source without locality to empty conceptId (document-level)', () => {
+    // When no locality is provided, the resolver resolves to the source document itself
+    const result = resolver.resolveCite({
+      ref: { source: 'VIM' },
+      locality: null,
+    });
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved).not.toBeNull();
+    expect(result.resolved!.registerId).toBe('vim-2012');
+  });
+
+  it('handles citation with null ref source', () => {
+    const result = resolver.resolveCite({
+      ref: { source: null, id: '3.1' },
+      locality: null,
+    });
+    expect(result.classification).toBe('unresolved-citation');
+  });
+
+  it('handles undefined citation', () => {
+    const result = resolver.resolveCite(undefined as any);
+    expect(result.classification).toBe('unresolved-citation');
+    expect(result.resolved).toBeNull();
+  });
+
+  it('classification and resolved always agree — internal implies non-null resolved', () => {
+    // If classification is internal-citation, resolved must be non-null
+    const internal = resolver.resolveCite({
+      ref: { source: 'VIM' },
+      locality: { reference_from: '2.2' },
+    });
+    if (internal.classification === 'internal-citation') {
+      expect(internal.resolved).not.toBeNull();
+    }
+  });
+
+  it('classification and resolved always agree — non-internal implies null resolved', () => {
+    const external = resolver.resolveCite({
+      ref: { source: 'Unknown' },
+      locality: null,
+    });
+    if (external.classification !== 'internal-citation') {
+      expect(external.resolved).toBeNull();
+    }
+  });
+
+  it('resolves with sourceDatasetId for cross-dataset detection', () => {
+    const result = resolver.resolveCite(
+      { ref: { source: 'VIM' }, locality: { reference_from: '2.2' } },
+      'vim-2012',
+    );
+    // Same dataset — still resolves internally
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved!.registerId).toBe('vim-2012');
+  });
+});
+
+describe('ReferenceResolver — URI pattern matching', () => {
+  it('matches URN patterns with wildcard', () => {
+    const { resolver, uriRouter } = createResolverPair();
+    uriRouter.registerDataset('iso-10303', '', '', ['urn:iso:std:iso:10303:*']);
+
+    const result = resolver.resolveReference('urn:iso:std:iso:10303:3.1.1.1');
+    expect(result.type).toBe('internal');
+    if (result.type === 'internal') {
+      expect(result.registerId).toBe('iso-10303');
+      expect(result.conceptId).toBe('3.1.1.1');
+    }
+  });
+
+  it('matches HTTPS patterns with wildcard', () => {
+    const { resolver, uriRouter } = createResolverPair();
+    uriRouter.registerDataset('iev', '', '', ['https://glossarist.org/iev/*']);
+
+    const result = resolver.resolveReference('https://glossarist.org/iev/concept/103-01-02');
+    expect(result.type).toBe('internal');
+    if (result.type === 'internal') {
+      expect(result.registerId).toBe('iev');
+      expect(result.conceptId).toBe('103-01-02');
+    }
+  });
+
+  it('returns unresolved for unknown URIs', () => {
+    const { resolver } = createResolverPair();
+    const result = resolver.resolveReference('https://unknown.example.com/concept/1');
+    expect(result.type).toBe('unresolved');
+  });
+
+});

package/src/__tests__/reference-resolver.test.ts

@@ -1,16 +1,21 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { createResolverPair } from './test-helpers';
+import type { ReferenceResolver } from '../adapters/ReferenceResolver';
+import type { UriRouter } from '../adapters/UriRouter';
 
 describe('ReferenceResolver', () => {
   let resolver: ReferenceResolver;
+  let uriRouter: UriRouter;
 
   beforeEach(() => {
-    resolver = new ReferenceResolver();
+    const pair = createResolverPair();
+    resolver = pair.resolver;
+    uriRouter = pair.uriRouter;
   });
 
   describe('resolveReference', () => {
     it('resolves internal URI for provided dataset', () => {
-      resolver.registerDataset('isotc204', ['urn:iso:std:iso:14812:*', 'https://glossarist.org/isotc204/*']);
+      uriRouter.registerDataset('isotc204', '', '', ['urn:iso:std:iso:14812:*', 'https://glossarist.org/isotc204/*']);
       const result = resolver.resolveReference('https://glossarist.org/isotc204/concept/3.1.1.1');
       expect(result).toEqual({
         type: 'internal',
@@ -21,7 +26,7 @@ describe('ReferenceResolver', () => {
     });
 
     it('resolves URN to internal for provided dataset', () => {
-      resolver.registerDataset('isotc204', ['urn:iso:std:iso:14812:*']);
+      uriRouter.registerDataset('isotc204', '', '', ['urn:iso:std:iso:14812:*']);
       const result = resolver.resolveReference('urn:iso:std:iso:14812:3.1.1.1');
       expect(result).toEqual({
         type: 'internal',
@@ -32,8 +37,8 @@ describe('ReferenceResolver', () => {
     });
 
     it('sets crossDataset=true when source dataset differs', () => {
-      resolver.registerDataset('iev', ['urn:iec:std:iec:60050:*']);
-      resolver.registerDataset('isotc204', ['urn:iso:std:iso:14812:*']);
+      uriRouter.registerDataset('iev', '', '', ['urn:iec:std:iec:60050:*']);
+      uriRouter.registerDataset('isotc204', '', '', ['urn:iso:std:iso:14812:*']);
       const result = resolver.resolveReference('urn:iec:std:iec:60050:103-01-02', 'isotc204');
       expect(result).toEqual({
         type: 'internal',
@@ -96,7 +101,7 @@ describe('ReferenceResolver', () => {
     });
 
     it('prefers provided dataset over routing', () => {
-      resolver.registerDataset('iev', ['urn:iec:std:iec:60050:*']);
+      uriRouter.registerDataset('iev', '', '', ['urn:iec:std:iec:60050:*']);
       resolver.loadRouting([
         {
           uri: 'urn:iec:std:iec:60050:*',

package/src/__tests__/resolve-view.test.ts

@@ -68,7 +68,7 @@ describe('ResolveView', () => {
 
   it('resolves the URI via the factory resolver', async () => {
     const factory = getFactory();
-    factory.resolver.registerDataset('test', ['https://glossarist.org/test/*']);
+    factory.uriRouter.registerDataset('test', '', '', ['https://glossarist.org/test/*']);
     const resolution = factory.resolve(TEST_URI);
     expect(resolution.type).toBe('internal');
     expect(resolution).toHaveProperty('registerId', 'test');