@glossarist/concept-browser 0.7.28 → 0.7.30

package/package.json

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

package/scripts/generate-data.mjs

@@ -924,6 +924,9 @@ for (let i = 0; i < config.datasets.length; i++) {
       tags: ds.tags || reg?.tags || [],
       color: ds.color || DS_PALETTE[i % DS_PALETTE.length],
     },
+    datasetUri: ds.uri || reg?.urn || undefined,
+    uriBase: config.uriBase || undefined,
+    uriAliases: ds.uriAliases || reg?.urnAliases || undefined,
   });
 }
 writeJson(path.join(PUBLIC, 'datasets.json'), registry);

package/src/adapters/DatasetAdapter.ts

@@ -51,10 +51,10 @@ export class DatasetAdapter {
     this.baseUrl = baseUrl;
   }
 
-  setSummaryManifest(summary: DatasetSummary): void {
+  setSummaryManifest(summary: DatasetSummary, registry?: { datasetUri?: string; uriBase?: string; uriAliases?: string[] }): void {
     this.manifest = {
       id: this.registerId,
-      datasetUri: '',
+      datasetUri: registry?.datasetUri || '',
       title: summary.title,
       description: summary.description,
       owner: summary.owner,
@@ -64,7 +64,8 @@ export class DatasetAdapter {
       conceptUrlTemplate: '',
       indexUrl: '',
       contextUrl: '',
-      uriBase: '',
+      uriBase: registry?.uriBase || '',
+      uriAliases: registry?.uriAliases,
       status: '',
       schemaVersion: '',
       tags: summary.tags,

package/src/adapters/factory.ts

@@ -36,7 +36,7 @@ export class AdapterFactory {
       adapters.push(adapter);
 
       if (reg.summary) {
-        adapter.setSummaryManifest(reg.summary);
+        adapter.setSummaryManifest(reg.summary, reg);
       } else {
         needManifest.push(adapter);
       }

package/src/adapters/types.ts

@@ -113,6 +113,9 @@ export interface DatasetRegistry {
   id: string;
   manifestUrl: string;
   summary?: DatasetSummary;
+  datasetUri?: string;
+  uriBase?: string;
+  uriAliases?: string[];
 }
 
 // ── Graph types ────────────────────────────────────────────────────────────

package/src/graph/GraphEngine.ts

@@ -1,6 +1,11 @@
 import type { GraphNode, GraphEdge } from '../adapters/types';
 import { UriRouter } from '../adapters/UriRouter';
 
+function hasDesignations(node: GraphNode): boolean {
+  const d = node.designations;
+  return d != null && typeof d === 'object' && Object.keys(d).length > 0;
+}
+
 /**
  * Directed multigraph engine for concept relationships.
  * Supports cross-register edges with stub nodes for unresolved targets.
@@ -18,6 +23,8 @@ export class GraphEngine {
       this.nodes.set(node.uri, node);
     } else if (node.loaded && !existing.loaded) {
       this.nodes.set(node.uri, node);
+    } else if (!existing.loaded && hasDesignations(node) && !hasDesignations(existing)) {
+      this.nodes.set(node.uri, node);
     }
   }
 

package/src/stores/vocabulary.ts

@@ -6,11 +6,12 @@ import type { Manifest, SearchHit, GraphEdge } from '../adapters/types';
 import type { Concept } from 'glossarist';
 import { conceptUri } from '../adapters/model-bridge';
 import { GraphEngine } from '../graph';
+import { UriRouter } from '../adapters/UriRouter';
 import { deduplicateSearchHits } from '../utils/search';
 
 export const useVocabularyStore = defineStore('vocabulary', () => {
   // State
-  const datasets = ref<Map<string, DatasetAdapter>>(new Map());
+  const datasets = shallowRef<Map<string, DatasetAdapter>>(new Map());
   const manifests = ref<Map<string, Manifest>>(new Map());
   const currentConcept = ref<Concept | null>(null);
   const currentRegisterId = ref<string>('');
@@ -54,12 +55,14 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
     error.value = null;
     try {
       const adapters = await factory.discoverDatasets(`${import.meta.env.BASE_URL}datasets.json`);
+      const newMap = new Map(datasets.value);
       for (const adapter of adapters) {
-        datasets.value.set(adapter.registerId, adapter);
+        newMap.set(adapter.registerId, adapter);
         if (adapter.manifest) {
           manifests.value.set(adapter.registerId, adapter.manifest);
         }
       }
+      datasets.value = newMap;
       initialized.value = true;
     } catch (e: unknown) {
       error.value = `Failed to discover datasets: ${e instanceof Error ? e.message : String(e)}`;
@@ -72,7 +75,9 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
     error.value = null;
     try {
       const adapter = await factory.loadDataset(registerId);
-      datasets.value.set(registerId, adapter);
+      const newMap = new Map(datasets.value);
+      newMap.set(registerId, adapter);
+      datasets.value = newMap;
       if (adapter.manifest) {
         manifests.value.set(registerId, adapter.manifest);
       }
@@ -136,29 +141,76 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
     touchGraph();
   }
 
-  async function loadEdges(adapter: DatasetAdapter) {
+  async function loadEdges(adapter: DatasetAdapter): Promise<GraphEdge[]> {
     try {
-      const [edges, domainNodes] = await Promise.all([
+      const [edges, domainNodes, graphNodes] = await Promise.all([
         adapter.loadEdgeIndex(),
         adapter.loadDomainNodes(),
+        adapter.loadGraphNodes(),
       ]);
       const engine = graph.value;
       for (const dn of domainNodes) {
         engine.addNode(dn);
       }
+      if (graphNodes.uriPrefix) {
+        for (const [id, designations, status] of graphNodes.nodes) {
+          engine.addNode({
+            uri: graphNodes.uriPrefix + id,
+            register: adapter.registerId,
+            conceptId: id,
+            designations: designations || {},
+            status: status || 'unknown',
+            loaded: false,
+          });
+        }
+      }
       for (const edge of edges) {
         engine.addEdge(edge);
       }
       edgeStatus.value[adapter.registerId] = { loaded: true, count: edges.length };
+      return edges;
     } catch {
       edgeStatus.value[adapter.registerId] = { loaded: false, count: 0 };
+      return [];
     }
   }
 
   async function ensureEdgesForDataset(registerId: string) {
     const adapter = datasets.value.get(registerId);
+    let loadedEdges: GraphEdge[] = [];
     if (adapter && !edgeStatus.value[registerId]?.loaded) {
-      await loadEdges(adapter);
+      loadedEdges = await loadEdges(adapter);
+    }
+
+    // Load graph nodes for any target datasets referenced by this dataset's edges
+    if (adapter && loadedEdges.length > 0) {
+      const targetRegisters = new Set<string>();
+      for (const edge of loadedEdges) {
+        const parsed = UriRouter.parseUri(edge.target);
+        if (parsed?.registerId && parsed.registerId !== registerId) {
+          targetRegisters.add(parsed.registerId);
+        }
+      }
+      await Promise.all([...targetRegisters].map(async (targetId) => {
+        const targetAdapter = datasets.value.get(targetId);
+        if (!targetAdapter) return;
+        try {
+          const gn = await targetAdapter.loadGraphNodes();
+          if (gn.uriPrefix) {
+            const engine = graph.value;
+            for (const [id, designations, status] of gn.nodes) {
+              engine.addNode({
+                uri: gn.uriPrefix + id,
+                register: targetId,
+                conceptId: id,
+                designations: designations || {},
+                status: status || 'unknown',
+                loaded: false,
+              });
+            }
+          }
+        } catch { /* non-critical */ }
+      }));
     }
 
     const index = await factory.loadCrossRefIndex();

package/src/views/DatasetView.vue

@@ -34,9 +34,9 @@ watch(adapter, (a) => {
   if (idlePreloadHandle !== null) return;
   if (!a || !a.index) return;
 
-  const schedule = typeof requestIdleCallback !== 'undefined'
-    ? requestIdleCallback
-    : (cb: () => void) => setTimeout(cb, 0);
+  const schedule: (cb: () => void) => number = typeof requestIdleCallback !== 'undefined'
+    ? (cb) => requestIdleCallback(cb, { timeout: 2000 })
+    : (cb) => window.setTimeout(cb, 0);
 
   idlePreloadHandle = schedule(() => {
     if (allChunksLoaded.value || !a.index) {
@@ -52,7 +52,7 @@ watch(adapter, (a) => {
       a.ensureChunksForRange(0, 100).catch(() => {});
     }
     idlePreloadHandle = null;
-  }, { timeout: 2000 } as any);
+  });
 });
 
 onBeforeUnmount(() => {