@glossarist/concept-browser 0.7.34 → 0.7.37

package/src/__tests__/sidebar-nav-highlighting.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import AppSidebar from '../components/AppSidebar.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+
+function makeManifest(id = 'test') {
+  return { id, datasetUri: `https://glossarist.org/${id}/concept`, title: `Test ${id}`, description: 'A test dataset',
+    owner: 'ISO', baseUrl: `/data/${id}`, languages: ['eng'], conceptCount: 50,
+    conceptUrlTemplate: `/data/${id}/concepts/{id}.json`, indexUrl: `/data/${id}/index.json`,
+    contextUrl: `/data/${id}/context.json`, uriBase: 'https://glossarist.org', status: 'published',
+    schemaVersion: '1.0', tags: [], lastUpdated: '2025-01-01', sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000, color: '#3366ff' } as any;
+}
+
+function createTestRouter(initialPath = '/') {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/stats', name: 'stats', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/about', name: 'about', component: { template: '<div/>' } },
+      { path: '/search', name: 'search', component: { template: '<div/>' } },
+      { path: '/about', name: 'about-global', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+function seedStore(datasets: string[] = ['test']) {
+  const store = useVocabularyStore();
+  for (const id of datasets) {
+    store.manifests.set(id, makeManifest(id));
+    store.datasets.set(id, { index: [], getConceptCount: () => 0, getConcepts: () => [] } as any);
+  }
+}
+
+/**
+ * Returns all <a> elements with the custom 'active' class.
+ * This is the class added by the isActive() function in AppSidebar,
+ * distinct from Vue Router's built-in router-link-active.
+ */
+function getActiveHrefs(wrapper: ReturnType<typeof mount>): string[] {
+  return wrapper.findAll('a.active').map(l => l.attributes('href') || '');
+}
+
+describe('AppSidebar — nav highlighting (isActive)', () => {
+  let pinia: ReturnType<typeof createPinia>;
+
+  beforeEach(() => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+  });
+
+  async function mountSidebar(initialPath = '/') {
+    const router = createTestRouter(initialPath);
+    router.push(initialPath);
+    await router.isReady();
+    return mount(AppSidebar, {
+      global: { plugins: [pinia, router], stubs: { NavIcon: true } },
+    });
+  }
+
+  // ── The bug: dataset About should NOT activate global About ─────────
+
+  it('on /dataset/test/about: ONLY dataset about link is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/about');
+    const activeHrefs = getActiveHrefs(wrapper);
+    // Dataset about link IS active
+    expect(activeHrefs).toContain('/dataset/test/about');
+    // Global /about link is NOT active (this was the bug)
+    expect(activeHrefs).not.toContain('/about');
+    // Only one active link total
+    expect(activeHrefs).toEqual(['/dataset/test/about']);
+  });
+
+  it('on /dataset/test/about: no link to /about (global) has active class', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/about');
+    const allLinks = wrapper.findAll('a');
+    const globalAboutLinks = allLinks.filter(l => l.attributes('href') === '/about');
+    // If global about link exists, it must NOT have custom active class
+    for (const link of globalAboutLinks) {
+      expect(link.classes()).not.toContain('active');
+    }
+  });
+
+  // ── Global About page still works ───────────────────────────────────
+
+
+  it('on /about: dataset about links are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/about');
+    const allLinks = wrapper.findAll('a');
+    const datasetAboutActive = allLinks.filter(
+      l => (l.attributes('href') || '').includes('/dataset/') &&
+           (l.attributes('href') || '').includes('/about') &&
+           l.classes().includes('active')
+    );
+    expect(datasetAboutActive).toEqual([]);
+  });
+
+  // ── Dataset root: dataset Concepts active, global Home not ──────────
+
+  it('on /dataset/test: dataset sub-nav is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test');
+    // Something should be active (the dataset concepts sub-page)
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('on /dataset/test: global nav links are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test');
+    const allLinks = wrapper.findAll('a');
+    // Global Search link must NOT be active
+    const searchActive = allLinks.filter(
+      l => l.attributes('href') === '/search' && l.classes().includes('active')
+    );
+    expect(searchActive).toEqual([]);
+  });
+
+  // ── Concept page: dataset Concepts still active ─────────────────────
+
+  it('on /dataset/test/concept/1.2: dataset sub-nav is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/concept/1.2');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ── Cross-dataset isolation ─────────────────────────────────────────
+
+  it('on /dataset/ds-a/about: ds-b about is NOT active', async () => {
+    seedStore(['ds-a', 'ds-b']);
+    const wrapper = await mountSidebar('/dataset/ds-a/about');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/dataset/ds-a/about');
+    expect(activeHrefs).not.toContain('/dataset/ds-b/about');
+  });
+
+  // ── Root route ──────────────────────────────────────────────────────
+
+  it('on /: Home link is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/');
+  });
+
+  it('on /: search and about are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).not.toContain('/search');
+    expect(activeHrefs).not.toContain('/about');
+  });
+
+  // ── Dataset stats page ──────────────────────────────────────────────
+
+  it('on /dataset/test/stats: stats sub-page is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/stats');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/dataset/test/stats');
+  });
+
+  it('on /dataset/test/stats: about sub-page is NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/stats');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).not.toContain('/dataset/test/about');
+  });
+});

package/src/__tests__/source-refs.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 import type { Resolution } from '../adapters/types';
 
 type InternalResolution = Extract<Resolution, { type: 'internal' }>;
@@ -10,13 +11,15 @@ function asInternal(r: Resolution | null): InternalResolution | null {
 
 describe('Source reference resolution (citation linking)', () => {
   let resolver: ReferenceResolver;
+  let uriRouter: UriRouter;
 
   beforeEach(() => {
-    resolver = new ReferenceResolver();
+    uriRouter = new UriRouter();
+    resolver = new ReferenceResolver(uriRouter);
     // Register datasets with URI patterns
-    resolver.registerDataset('vim-2012', ['urn:oiml:pub:v:2:2012*']);
-    resolver.registerDataset('viml-2022', ['urn:oiml:pub:v:1:2022*']);
-    resolver.registerDataset('vim-2007', ['urn:oiml:pub:v:2:2007*']);
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    uriRouter.registerDataset('viml-2022', '', '', ['urn:oiml:pub:v:1:2022*']);
+    uriRouter.registerDataset('vim-2007', '', '', ['urn:oiml:pub:v:2:2007*']);
   });
 
   describe('hasSourceRef', () => {
@@ -132,7 +135,7 @@ describe('Source reference resolution (citation linking)', () => {
 
   describe('ISO source references', () => {
     it('resolves ISO/IEC references when registered', () => {
-      resolver.registerDataset('iso-17000', ['urn:iso:std:iso:iec:17000*']);
+      uriRouter.registerDataset('iso-17000', '', '', ['urn:iso:std:iso:iec:17000*']);
       resolver.registerSourceRef('ISO/IEC 17000:2020', 'iso-17000', 'urn:iso:std:iso:iec:17000');
 
       const result = resolver.resolveCitation('ISO/IEC 17000:2020', '3.1', 'viml-2022');
@@ -171,7 +174,7 @@ describe('Source reference resolution (citation linking)', () => {
     });
 
     it('handles source strings with special characters', () => {
-      resolver.registerDataset('vim-1993', ['urn:oiml:pub:v:2:1993*']);
+      uriRouter.registerDataset('vim-1993', '', '', ['urn:oiml:pub:v:2:1993*']);
       resolver.registerSourceRef('OIML V 2:1993', 'vim-1993', 'urn:oiml:pub:v:2:1993');
       const result = resolver.resolveCitation('OIML V 2:1993', '3.6');
       expect(asInternal(result)?.registerId).toBe('vim-1993');

package/src/__tests__/test-helpers.ts

@@ -2,6 +2,8 @@ import { createPinia, setActivePinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import { LocalizedConcept } from 'glossarist';
 import type { Manifest, ConceptSummary, SearchHit } from '../adapters/types';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 
 // ── Manifest Factory ──────────────────────────────────────────────────
 
@@ -173,3 +175,21 @@ export function setupPinia() {
   setActivePinia(pinia);
   return pinia;
 }
+
+// ── ReferenceResolver Setup ──────────────────────────────────────────
+
+export interface ResolverPair {
+  uriRouter: UriRouter;
+  resolver: ReferenceResolver;
+}
+
+/**
+ * Create a UriRouter + ReferenceResolver pair for testing.
+ * Use `pair.uriRouter.registerDataset()` to register URI patterns,
+ * then use `pair.resolver` for reference resolution.
+ */
+export function createResolverPair(): ResolverPair {
+  const uriRouter = new UriRouter();
+  const resolver = new ReferenceResolver(uriRouter);
+  return { uriRouter, resolver };
+}

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

@@ -1,12 +1,16 @@
 import { describe, it, expect } from 'vitest';
 import { UriRouter } from '../adapters/UriRouter';
 
-const MOCK_MANIFEST = { uriBase: 'https://glossarist.org' } as any;
-
 describe('UriRouter', () => {
+  const URI_BASE = 'https://glossarist.org';
+
+  function register(router: UriRouter, registerId: string, baseUrl: string = `/data/${registerId}`) {
+    router.registerDataset(registerId, baseUrl, URI_BASE, [`${URI_BASE}/${registerId}/*`]);
+  }
+
   it('resolves URIs for registered datasets', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
 
     const resolved = router.resolveUri('https://glossarist.org/iev/concept/103-01-02');
     expect(resolved).toEqual({ registerId: 'iev', conceptId: '103-01-02' });
@@ -14,7 +18,7 @@ describe('UriRouter', () => {
 
   it('resolves URIs with multi-part concept IDs', () => {
     const router = new UriRouter();
-    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
+    register(router, 'isotc204');
 
     const resolved = router.resolveUri('https://glossarist.org/isotc204/concept/3.1.1.1');
     expect(resolved).toEqual({ registerId: 'isotc204', conceptId: '3.1.1.1' });
@@ -22,43 +26,66 @@ describe('UriRouter', () => {
 
   it('returns null for unknown register', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
 
     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', MOCK_MANIFEST);
+    register(router, 'iev');
 
     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);
+    register(router, 'iev');
     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', MOCK_MANIFEST);
-    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
+    register(router, 'iev');
+    register(router, 'isotc211');
 
     expect(router.getRegisteredIds()).toEqual(['iev', 'isotc211']);
   });
 
   it('resolves across multiple registers', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
-    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
-    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
+    register(router, 'iev');
+    register(router, 'isotc211');
+    register(router, 'isotc204');
 
     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');
     expect(router.resolveUri('https://glossarist.org/isotc204/concept/3.1.1.1')?.registerId).toBe('isotc204');
   });
 
+  it('resolves URN patterns with wildcard', () => {
+    const router = new UriRouter();
+    router.registerDataset('iso-10303', '', '', ['urn:iso:std:iso:10303:*']);
+
+    const resolved = router.resolveUri('urn:iso:std:iso:10303:3.1.1.1');
+    expect(resolved).toEqual({ registerId: 'iso-10303', conceptId: '3.1.1.1' });
+  });
+
+  it('resolves URN prefix to registerId', () => {
+    const router = new UriRouter();
+    router.registerDataset('iso-10303', '', '', ['urn:iso:std:iso:10303:*']);
+
+    expect(router.resolveUrn('urn:iso:std:iso:10303')).toBe('iso-10303');
+    expect(router.resolveUrn('urn:unknown:prefix')).toBeNull();
+  });
+
+  it('returns uriBase for registered dataset', () => {
+    const router = new UriRouter();
+    register(router, 'iev');
+    expect(router.getUriBase('iev')).toBe(URI_BASE);
+    expect(router.getUriBase('unknown')).toBe('');
+  });
+
   describe('parseUri (static)', () => {
     it('extracts register and concept from any glossarist URI', () => {
       expect(UriRouter.parseUri('https://glossarist.org/iev/concept/103-01-02')).toEqual({

package/src/adapters/DatasetAdapter.ts

@@ -9,10 +9,9 @@ import type {
   SectionNode,
   DatasetSummary,
 } from './types';
-import type { Concept, LocalizedConcept, Designation, RelatedConcept } from 'glossarist';
-import { conceptFromJson, conceptUri } from './model-bridge';
-import { UriRouter } from './UriRouter';
-import { slugify } from '../utils/slugify';
+import type { Concept } from 'glossarist';
+import { conceptFromJson } from './model-bridge';
+import { GraphDataSource } from './GraphDataSource';
 
 // ── Wire-format types for JSON responses ────────────────────────────────────
 
@@ -33,36 +32,6 @@ interface IndexConceptJson {
   groups?: string[];
 }
 
-interface DomainNodeJson {
-  uri?: string;
-  id?: string;
-  registerId?: string;
-  label?: string;
-  names?: Record<string, string>;
-  conceptCount?: number;
-  children?: DomainNodeJson[];
-}
-
-interface SectionJson {
-  id: string;
-  names?: Record<string, string>;
-  children?: SectionJson[];
-}
-
-function resolveRefTarget(rc: RelatedConcept, uriBase: string, registerId: string, urnMap?: ReadonlyMap<string, string>): string {
-  if (!rc.ref) return '';
-  const ref = rc.ref;
-  if (ref.id) {
-    let reg = registerId;
-    if (ref.source && !ref.source.startsWith('http')) {
-      reg = urnMap?.get(ref.source) ?? ref.source;
-    }
-    return `${uriBase}/${reg}/concept/${ref.id}`;
-  }
-  if (ref.source && ref.source.startsWith('http')) return ref.source;
-  return ref.source || '';
-}
-
 export class DatasetAdapter {
   private positionIndex = new Map<string, number>();
   private _urnMap: ReadonlyMap<string, string> = new Map();
@@ -75,6 +44,7 @@ export class DatasetAdapter {
   private conceptCache = new Map<string, Concept>();
   private static MAX_CACHE = 100;
   private summaryMap = new Map<string, ConceptSummary>();
+  private designationMap = new Map<string, string>();
   private loadedChunks = new Set<number>();
   private indexMeta: { conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] } | null = null;
 
@@ -158,11 +128,17 @@ export class DatasetAdapter {
   private buildSummaryIndex() {
     this.summaryMap.clear();
     this.positionIndex.clear();
+    this.designationMap.clear();
     for (let i = 0; i < this.index!.concepts.length; i++) {
       const entry = this.index!.concepts[i];
       if (entry) {
         this.summaryMap.set(entry.id, entry);
         this.positionIndex.set(entry.id, i);
+        for (const term of Object.values(entry.designations)) {
+          if (term && !this.designationMap.has(term.toLowerCase())) {
+            this.designationMap.set(term.toLowerCase(), entry.id);
+          }
+        }
       }
     }
   }
@@ -294,6 +270,11 @@ export class DatasetAdapter {
     return this.summaryMap.get(conceptId);
   }
 
+  /** Look up a concept ID by its designation string (case-insensitive). */
+  lookupByDesignation(designation: string): string | undefined {
+    return this.designationMap.get(designation.toLowerCase());
+  }
+
   getConcepts(): (ConceptSummary | undefined)[] {
     return this.index?.concepts ?? [];
   }
@@ -376,131 +357,42 @@ export class DatasetAdapter {
     this._urnMap = map;
   }
 
-  extractEdges(concept: Concept): GraphEdge[] {
-    const edges: GraphEdge[] = [];
-    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
-    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
-
-    // Managed concept level relationships
-    for (const rc of concept.relatedConcepts) {
-      const target = resolveRefTarget(rc, uriBase, this.registerId, this._urnMap);
-      if (target && target !== sourceUri) {
-        const parsed = UriRouter.parseUri(target);
-        edges.push({
-          source: sourceUri,
-          target,
-          type: rc.type || 'references',
-          label: rc.content || undefined,
-          register: parsed?.registerId ?? this.registerId,
-        });
-      }
-    }
-
-    // Per-localization references (from inline extraction in generate-data)
-    for (const lang of concept.languages) {
-      const lc = concept.localization(lang);
-      if (!lc) continue;
-      for (const rc of lc.related) {
-        const target = resolveRefTarget(rc, uriBase, this.registerId, this._urnMap);
-        if (target && target !== sourceUri) {
-          const parsed = UriRouter.parseUri(target);
-          edges.push({
-            source: sourceUri,
-            target,
-            type: rc.type || 'references',
-            label: rc.content || undefined,
-            register: parsed?.registerId ?? this.registerId,
-            lang,
-          });
-        }
-      }
-    }
-
-    return edges;
+  get dataUrl(): string {
+    return this.baseUrl;
   }
 
-  extractDomainEdges(concept: Concept): GraphEdge[] {
-    const edges: GraphEdge[] = [];
-    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
-    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
-
-    for (const lang of concept.languages) {
-      const lc = concept.localization(lang);
-      if (lc?.domain) {
-        edges.push({
-          source: sourceUri,
-          target: `${uriBase}/${this.registerId}/domain/${slugify(lc.domain)}`,
-          type: 'domain',
-          label: lc.domain,
-          register: this.registerId,
-          lang,
-        });
-      }
-    }
-    return edges;
+  get urnMap(): ReadonlyMap<string, string> {
+    return this._urnMap;
   }
 
-  async loadDomainNodes(): Promise<GraphNode[]> {
-    const resp = await fetch(`${this.baseUrl}/domain-nodes.json`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return (data.domainNodes || []).map((dn: DomainNodeJson) => this.mapDomainNode(dn));
+  private _graphDataSource: GraphDataSource | null = null;
+  get graphDataSource(): GraphDataSource {
+    if (!this._graphDataSource) this._graphDataSource = new GraphDataSource(this);
+    return this._graphDataSource;
   }
 
-  private mapDomainNode(dn: DomainNodeJson): GraphNode {
-    const node: GraphNode = {
-      uri: dn.uri ?? '',
-      register: dn.registerId ?? '',
-      conceptId: dn.uri?.split('/domain/')[1] || dn.id || '',
-      designations: dn.names || (dn.label ? { eng: dn.label } : {}),
-      status: 'domain',
-      loaded: true,
-      nodeType: 'domain' as const,
-      conceptCount: dn.conceptCount || 0,
-    };
-    if (dn.children && dn.children.length > 0) {
-      node.children = dn.children.map((c) => this.mapSectionNode(c));
-    }
-    return node;
-  }
-
-  private mapSectionNode(dn: DomainNodeJson): SectionNode {
-    const node: SectionNode = {
-      id: dn.id ?? '',
-      names: dn.names || (dn.label ? { eng: dn.label } : {}),
-      conceptCount: dn.conceptCount || 0,
-    };
-    if (dn.children && dn.children.length > 0) {
-      node.children = dn.children.map((c) => this.mapSectionNode(c));
-    }
-    return node;
+  extractEdges(concept: Concept): GraphEdge[] {
+    return this.graphDataSource.extractEdges(concept);
   }
 
-  getSectionTree(): SectionNode[] {
-    const nodes = this.manifest?.sections;
-    if (!nodes || nodes.length === 0) return [];
-    return nodes.map(s => this.mapManifestSection(s));
+  extractDomainEdges(concept: Concept): GraphEdge[] {
+    return this.graphDataSource.extractDomainEdges(concept);
   }
 
-  private mapManifestSection(s: SectionJson): SectionNode {
-    const node: SectionNode = { id: s.id, names: s.names || {}, conceptCount: 0 };
-    if (s.children && s.children.length > 0) {
-      node.children = s.children.map(c => this.mapManifestSection(c));
-    }
-    return node;
+  async loadDomainNodes(): Promise<GraphNode[]> {
+    return this.graphDataSource.loadDomainNodes();
   }
 
   async loadEdgeIndex(): Promise<GraphEdge[]> {
-    const resp = await fetch(`${this.baseUrl}/edges.json`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return data.edges ?? [];
+    return this.graphDataSource.loadEdgeIndex();
   }
 
   async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
-    const resp = await fetch(`${this.baseUrl}/graph-nodes.json`);
-    if (!resp.ok) return { uriPrefix: '', nodes: [] };
-    return await resp.json();
+    return this.graphDataSource.loadGraphNodes();
+  }
+
+  getSectionTree(): SectionNode[] {
+    return this.graphDataSource.getSectionTree();
   }
 
   getLanguages(): string[] {