@glossarist/concept-browser 0.7.21 → 0.7.23

package/src/data/taxonomies.json

@@ -243,24 +243,6 @@
         "prefLabel": "related concept (narrower)",
         "definition": "Associative relationship to a concept with narrower scope (ISO 25964 / TBX)."
       },
-      "sequentially_related": {
-        "id": "sequentially_related",
-        "iri": "gloss:rel/sequentially_related",
-        "prefLabel": "sequentially related",
-        "definition": "Sequential spatiotemporal relationship (ISO 25964 / TBX)."
-      },
-      "spatially_related": {
-        "id": "spatially_related",
-        "iri": "gloss:rel/spatially_related",
-        "prefLabel": "spatially related",
-        "definition": "Spatial relationship (ISO 25964 / TBX)."
-      },
-      "temporally_related": {
-        "id": "temporally_related",
-        "iri": "gloss:rel/temporally_related",
-        "prefLabel": "temporally related",
-        "definition": "Temporal relationship (ISO 25964 / TBX)."
-      },
       "homograph": {
         "id": "homograph",
         "iri": "gloss:rel/homograph",
@@ -284,6 +266,252 @@
         "iri": "gloss:rel/short_form_for",
         "prefLabel": "short form for",
         "definition": "This designation is a short form of another designation."
+      },
+      "deprecated_by": {
+        "id": "deprecated_by",
+        "iri": "https://glossarist.org/ontologies/relationship-type#deprecated_by",
+        "prefLabel": "deprecated by",
+        "definition": "This concept has been deprecated by another concept (ISO 10241-1)."
+      },
+      "replaces": {
+        "id": "replaces",
+        "iri": "https://glossarist.org/ontologies/relationship-type#replaces",
+        "prefLabel": "replaces",
+        "definition": "This concept replaces another concept (ISO 10241-1)."
+      },
+      "replaced_by": {
+        "id": "replaced_by",
+        "iri": "https://glossarist.org/ontologies/relationship-type#replaced_by",
+        "prefLabel": "replaced by",
+        "definition": "This concept has been replaced by another concept (ISO 10241-1)."
+      },
+      "invalidates": {
+        "id": "invalidates",
+        "iri": "https://glossarist.org/ontologies/relationship-type#invalidates",
+        "prefLabel": "invalidates",
+        "definition": "This concept invalidates another concept, indicating it contains a substantial error and should not be used (ISO 19135)."
+      },
+      "invalidated_by": {
+        "id": "invalidated_by",
+        "iri": "https://glossarist.org/ontologies/relationship-type#invalidated_by",
+        "prefLabel": "invalidated by",
+        "definition": "This concept has been invalidated by another concept due to a substantial error (ISO 19135)."
+      },
+      "retires": {
+        "id": "retires",
+        "iri": "https://glossarist.org/ontologies/relationship-type#retires",
+        "prefLabel": "retires",
+        "definition": "This concept retires another concept, indicating it is no longer recommended for use (ISO 19135)."
+      },
+      "retired_by": {
+        "id": "retired_by",
+        "iri": "https://glossarist.org/ontologies/relationship-type#retired_by",
+        "prefLabel": "retired by",
+        "definition": "This concept has been retired by another concept (ISO 19135)."
+      },
+      "has_concept": {
+        "id": "has_concept",
+        "iri": "https://glossarist.org/ontologies/relationship-type#has_concept",
+        "prefLabel": "has concept",
+        "definition": "This concept has the nominated concept as a specialisation of its definition (ISO 19135)."
+      },
+      "is_concept_of": {
+        "id": "is_concept_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#is_concept_of",
+        "prefLabel": "is concept of",
+        "definition": "This concept is a specialisation of the source concept (ISO 19135)."
+      },
+      "instance_of": {
+        "id": "instance_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#instance_of",
+        "prefLabel": "instance of",
+        "definition": "This concept is an instance of the nominated concept (ISO 19135)."
+      },
+      "has_instance": {
+        "id": "has_instance",
+        "iri": "https://glossarist.org/ontologies/relationship-type#has_instance",
+        "prefLabel": "has instance",
+        "definition": "This concept has the nominated concept as an instance (ISO 19135)."
+      },
+      "has_definition": {
+        "id": "has_definition",
+        "iri": "https://glossarist.org/ontologies/relationship-type#has_definition",
+        "prefLabel": "has definition",
+        "definition": "This concept has the nominated concept as its definition (ISO 19135)."
+      },
+      "definition_of": {
+        "id": "definition_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#definition_of",
+        "prefLabel": "definition of",
+        "definition": "This concept is the definition of the source concept (ISO 19135)."
+      },
+      "has_part": {
+        "id": "has_part",
+        "iri": "https://glossarist.org/ontologies/relationship-type#has_part",
+        "prefLabel": "has part",
+        "definition": "This concept has the nominated concept as a part of its composition (ISO 19135)."
+      },
+      "is_part_of": {
+        "id": "is_part_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#is_part_of",
+        "prefLabel": "is part of",
+        "definition": "This concept is a part of the source concept (ISO 19135)."
+      },
+      "inherits": {
+        "id": "inherits",
+        "iri": "https://glossarist.org/ontologies/relationship-type#inherits",
+        "prefLabel": "inherits",
+        "definition": "This concept inherits and extends properties from the nominated concept (ISO 19135)."
+      },
+      "inherited_by": {
+        "id": "inherited_by",
+        "iri": "https://glossarist.org/ontologies/relationship-type#inherited_by",
+        "prefLabel": "inherited by",
+        "definition": "This concept is inherited by the source concept (ISO 19135)."
+      },
+      "has_version": {
+        "id": "has_version",
+        "iri": "https://glossarist.org/ontologies/relationship-type#has_version",
+        "prefLabel": "has version",
+        "definition": "This concept has the nominated concept as a version (ISO 19135)."
+      },
+      "version_of": {
+        "id": "version_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#version_of",
+        "prefLabel": "version of",
+        "definition": "This concept is a version of the source concept (ISO 19135)."
+      },
+      "current_version": {
+        "id": "current_version",
+        "iri": "https://glossarist.org/ontologies/relationship-type#current_version",
+        "prefLabel": "current version",
+        "definition": "This concept has the nominated concept as its current version (ISO 19135)."
+      },
+      "current_version_of": {
+        "id": "current_version_of",
+        "iri": "https://glossarist.org/ontologies/relationship-type#current_version_of",
+        "prefLabel": "current version of",
+        "definition": "This concept is the current version of the source concept (ISO 19135)."
+      },
+      "broader": {
+        "id": "broader",
+        "iri": "https://glossarist.org/ontologies/relationship-type#broader",
+        "prefLabel": "broader",
+        "definition": "This concept has a broader (more general) scope (SKOS)."
+      },
+      "narrower": {
+        "id": "narrower",
+        "iri": "https://glossarist.org/ontologies/relationship-type#narrower",
+        "prefLabel": "narrower",
+        "definition": "This concept has a narrower (more specific) scope (SKOS)."
+      },
+      "broader_generic": {
+        "id": "broader_generic",
+        "iri": "https://glossarist.org/ontologies/relationship-type#broader_generic",
+        "prefLabel": "broader (generic)",
+        "definition": "Generic (is-a) broader relationship (ISO 25964)."
+      },
+      "narrower_generic": {
+        "id": "narrower_generic",
+        "iri": "https://glossarist.org/ontologies/relationship-type#narrower_generic",
+        "prefLabel": "narrower (generic)",
+        "definition": "Generic (is-a) narrower relationship (ISO 25964)."
+      },
+      "broader_partitive": {
+        "id": "broader_partitive",
+        "iri": "https://glossarist.org/ontologies/relationship-type#broader_partitive",
+        "prefLabel": "broader (partitive)",
+        "definition": "Partitive (whole-of) broader relationship (ISO 25964)."
+      },
+      "narrower_partitive": {
+        "id": "narrower_partitive",
+        "iri": "https://glossarist.org/ontologies/relationship-type#narrower_partitive",
+        "prefLabel": "narrower (partitive)",
+        "definition": "Partitive (part-of) narrower relationship (ISO 25964)."
+      },
+      "broader_instantial": {
+        "id": "broader_instantial",
+        "iri": "https://glossarist.org/ontologies/relationship-type#broader_instantial",
+        "prefLabel": "broader (instantial)",
+        "definition": "Instantial broader relationship (ISO 25964)."
+      },
+      "narrower_instantial": {
+        "id": "narrower_instantial",
+        "iri": "https://glossarist.org/ontologies/relationship-type#narrower_instantial",
+        "prefLabel": "narrower (instantial)",
+        "definition": "Instantial narrower relationship (ISO 25964)."
+      },
+      "equivalent": {
+        "id": "equivalent",
+        "iri": "https://glossarist.org/ontologies/relationship-type#equivalent",
+        "prefLabel": "equivalent",
+        "definition": "This concept is equivalent to another concept (SKOS)."
+      },
+      "close_match": {
+        "id": "close_match",
+        "iri": "https://glossarist.org/ontologies/relationship-type#close_match",
+        "prefLabel": "close match",
+        "definition": "This concept is a close match to another concept (SKOS)."
+      },
+      "broad_match": {
+        "id": "broad_match",
+        "iri": "https://glossarist.org/ontologies/relationship-type#broad_match",
+        "prefLabel": "broad match",
+        "definition": "This concept has a broader match to another concept (SKOS)."
+      },
+      "narrow_match": {
+        "id": "narrow_match",
+        "iri": "https://glossarist.org/ontologies/relationship-type#narrow_match",
+        "prefLabel": "narrow match",
+        "definition": "This concept has a narrower match to another concept (SKOS)."
+      },
+      "related_match": {
+        "id": "related_match",
+        "iri": "https://glossarist.org/ontologies/relationship-type#related_match",
+        "prefLabel": "related match",
+        "definition": "This concept has a related match to another concept (SKOS)."
+      },
+      "see": {
+        "id": "see",
+        "iri": "https://glossarist.org/ontologies/relationship-type#see",
+        "prefLabel": "see",
+        "definition": "Reference to another concept (ISO 10241-1)."
+      },
+      "related_concept": {
+        "id": "related_concept",
+        "iri": "https://glossarist.org/ontologies/relationship-type#related_concept",
+        "prefLabel": "related concept",
+        "definition": "Associative relationship to another concept (ISO 25964)."
+      },
+      "references": {
+        "id": "references",
+        "iri": "https://glossarist.org/ontologies/relationship-type#references",
+        "prefLabel": "references",
+        "definition": "This concept references another concept."
+      },
+      "sequentially_related": {
+        "id": "sequentially_related",
+        "iri": "gloss:rel/sequentially_related",
+        "prefLabel": "sequentially related",
+        "definition": "Sequential spatiotemporal relationship (ISO 25964 / TBX)."
+      },
+      "spatially_related": {
+        "id": "spatially_related",
+        "iri": "gloss:rel/spatially_related",
+        "prefLabel": "spatially related",
+        "definition": "Spatial relationship (ISO 25964 / TBX)."
+      },
+      "temporally_related": {
+        "id": "temporally_related",
+        "iri": "gloss:rel/temporally_related",
+        "prefLabel": "temporally related",
+        "definition": "Temporal relationship (ISO 25964 / TBX)."
+      },
+      "exact_match": {
+        "id": "exact_match",
+        "iri": "gloss:rel/exact_match",
+        "prefLabel": "exact match",
+        "definition": "Cross-vocabulary exact equivalence (SKOS skos:exactMatch)."
       }
     }
   },

package/src/directives/v-math.ts

@@ -4,8 +4,7 @@ import { loadPlurimath, mathToHtml } from '../utils/plurimath';
 let loaded = false;
 
 function upgrade(el: HTMLElement) {
-  const pending = el.querySelectorAll('.math-pending');
-  if (!pending.length) return;
+  if (!el.querySelector('.math-pending')) return;
 
   if (!loaded) {
     loadPlurimath().then(() => {
@@ -15,7 +14,7 @@ function upgrade(el: HTMLElement) {
     return;
   }
 
-  pending.forEach((span) => {
+  el.querySelectorAll('.math-pending').forEach((span) => {
     const expr = (span as HTMLElement).dataset.expr;
     const format = (span as HTMLElement).dataset.format || 'asciimath';
     const bold = span.classList.contains('math-bold');

package/src/graph/GraphEngine.ts

@@ -72,15 +72,23 @@ export class GraphEngine {
     if (from) {
       const adj = this.adjacency.get(from);
       if (!adj) return [];
-      return [...adj.values()].flat();
+      const result: GraphEdge[] = [];
+      for (const list of adj.values()) {
+        for (const e of list) result.push(e);
+      }
+      return result;
     }
-    return this.edges;
+    return [...this.edges];
   }
 
   getIncomingEdges(uri: string): GraphEdge[] {
     const adj = this.reverseAdjacency.get(uri);
     if (!adj) return [];
-    return [...adj.values()].flat();
+    const result: GraphEdge[] = [];
+    for (const list of adj.values()) {
+      for (const e of list) result.push(e);
+    }
+    return result;
   }
 
   getNeighbors(uri: string): { outgoing: string[]; incoming: string[] } {
@@ -100,9 +108,10 @@ export class GraphEngine {
     const collectedNodes: GraphNode[] = [];
     const collectedEdges: GraphEdge[] = [];
     const queue: { uri: string; d: number }[] = [{ uri: rootUri, d: 0 }];
+    let head = 0;
 
-    while (queue.length > 0) {
-      const { uri, d } = queue.shift()!;
+    while (head < queue.length) {
+      const { uri, d } = queue[head++];
       if (visited.has(uri) || d > depth) continue;
       visited.add(uri);
 
@@ -137,4 +146,12 @@ export class GraphEngine {
   get edgeCount(): number {
     return this.edges.length;
   }
+
+  clear(): void {
+    this.nodes.clear();
+    this.edges.length = 0;
+    this.edgeKeys.clear();
+    this.adjacency.clear();
+    this.reverseAdjacency.clear();
+  }
 }

package/src/i18n/index.ts

@@ -1,4 +1,5 @@
 import { ref } from 'vue';
+import { DEFAULT_LANG } from '../utils/lang';
 
 // Auto-discover all locale YAML files — adding a new .yml file is all that's needed
 const localeModules = import.meta.glob<{ default: Record<string, string> }>('./locales/*.yml', { eager: true });
@@ -14,7 +15,6 @@ for (const path of Object.keys(localeModules)) {
   }
 }
 
-const DEFAULT_LANG = 'eng';
 const stored = typeof localStorage !== 'undefined'
   ? (localStorage.getItem('ui-lang') || DEFAULT_LANG)
   : DEFAULT_LANG;

package/src/stores/vocabulary.ts

@@ -1,11 +1,12 @@
 import { defineStore } from 'pinia';
-import { ref, computed, toRaw } from 'vue';
+import { ref, shallowRef, computed } from 'vue';
 import { getFactory } from '../adapters/factory';
 import type { DatasetAdapter } from '../adapters/DatasetAdapter';
 import type { Manifest, SearchHit, GraphEdge } from '../adapters/types';
 import type { Concept } from 'glossarist';
 import { conceptUri } from '../adapters/model-bridge';
 import { GraphEngine } from '../graph';
+import { deduplicateSearchHits } from '../utils/search';
 
 export const useVocabularyStore = defineStore('vocabulary', () => {
   // State
@@ -16,7 +17,7 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
   const currentConceptId = ref<string>('');
   const loading = ref(false);
   const error = ref<string | null>(null);
-  const graph = ref(new GraphEngine());
+  const graph = shallowRef(new GraphEngine());
   const conceptEdges = ref<GraphEdge[]>([]);
   const initialized = ref(false);
 
@@ -76,75 +77,19 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         manifests.value.set(registerId, adapter.manifest);
       }
 
-      // Load pre-computed edges (lightweight)
-      await loadEdges(adapter);
-
       touchGraph();
-
-      // Seed graph nodes lazily — don't block UI for large datasets
-      seedGraphNodes(registerId, adapter);
     } catch (e: unknown) {
       error.value = `Failed to load dataset ${registerId}: ${e instanceof Error ? e.message : String(e)}`;
       throw e;
     }
   }
 
-  function seedGraphNodes(registerId: string, adapter: DatasetAdapter, sync = false) {
-    const entries = adapter.getConcepts();
-
-    if (sync) {
-      for (const entry of entries) {
-        if (!entry) continue;
-        graph.value.addNode({
-          uri: factory.router.buildUri(registerId, entry.id),
-          register: registerId,
-          conceptId: entry.id,
-          designations: entry.designations,
-          status: entry.status,
-          loaded: false,
-        });
-      }
-      touchGraph();
-      return;
-    }
-
-    const batchSize = 500;
-    let offset = 0;
-    const schedule = typeof requestIdleCallback !== 'undefined'
-      ? requestIdleCallback
-      : (cb: () => void) => setTimeout(cb, 0);
-
-    function processBatch() {
-      const end = Math.min(offset + batchSize, entries.length);
-      for (let i = offset; i < end; i++) {
-        const entry = entries[i];
-        if (!entry) continue;
-        graph.value.addNode({
-          uri: factory.router.buildUri(registerId, entry.id),
-          register: registerId,
-          conceptId: entry.id,
-          designations: entry.designations,
-          status: entry.status,
-          loaded: false,
-        });
-      }
-      offset = end;
-      if (offset < entries.length) {
-        schedule(processBatch);
-      } else {
-        touchGraph();
-      }
-    }
-
-    schedule(processBatch);
-  }
-
   async function loadAllGraphData() {
     if (!initialized.value) {
       await discoverDatasets();
     }
 
-    const engine = toRaw(graph.value);
+    const engine = graph.value;
     const adapters = factory.getAdapters();
 
     await Promise.allSettled(adapters.map(async (adapter) => {
@@ -197,11 +142,12 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         adapter.loadEdgeIndex(),
         adapter.loadDomainNodes(),
       ]);
+      const engine = graph.value;
       for (const dn of domainNodes) {
-        graph.value.addNode(dn);
+        engine.addNode(dn);
       }
       for (const edge of edges) {
-        graph.value.addEdge(edge);
+        engine.addEdge(edge);
       }
       edgeStatus.value[adapter.registerId] = { loaded: true, count: edges.length };
     } catch {
@@ -209,19 +155,19 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
     }
   }
 
-  async function ensureAllEdgesLoaded() {
-    for (const [id, adapter] of datasets.value) {
-      if (!edgeStatus.value[id]?.loaded) {
-        try {
-          const edges = await adapter.loadEdgeIndex();
-          for (const edge of edges) {
-            graph.value.addEdge(edge);
-          }
-          edgeStatus.value[id] = { loaded: true, count: edges.length };
-        } catch {
-          edgeStatus.value[id] = { loaded: false, count: 0 };
-        }
-      }
+  async function ensureEdgesForDataset(registerId: string) {
+    const adapter = datasets.value.get(registerId);
+    if (adapter && !edgeStatus.value[registerId]?.loaded) {
+      await loadEdges(adapter);
+    }
+
+    const index = await factory.loadCrossRefIndex();
+    const refs = index[registerId] || [];
+    for (const refId of refs) {
+      if (edgeStatus.value[refId]?.loaded) continue;
+      const refAdapter = datasets.value.get(refId);
+      if (!refAdapter) continue;
+      await loadEdges(refAdapter);
     }
   }
 
@@ -234,16 +180,18 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
       const adapter = datasets.value.get(registerId);
       if (!adapter) throw new Error(`Dataset ${registerId} not loaded`);
 
-      const concept = await adapter.fetchConcept(conceptId);
+      // Fetch concept and cross-dataset edges in parallel
+      const [concept] = await Promise.all([
+        adapter.fetchConcept(conceptId),
+        ensureEdgesForDataset(registerId),
+      ]);
       currentConcept.value = concept;
 
-      // Extract and register edges for this specific concept
       const edges = adapter.extractEdges(concept);
       const domainEdges = adapter.extractDomainEdges(concept);
       const uriBase = adapter.manifest?.uriBase || 'https://glossarist.org';
       const uri = conceptUri(concept, registerId, uriBase);
 
-      // Update graph node with full data
       const designations: Record<string, string> = {};
       const indexEntry = adapter.getIndexEntry(conceptId);
       if (indexEntry) {
@@ -258,7 +206,8 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         }
       }
 
-      graph.value.addNode({
+      const engine = graph.value;
+      engine.addNode({
         uri,
         register: registerId,
         conceptId,
@@ -268,14 +217,14 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
       });
 
       for (const edge of edges) {
-        graph.value.addEdge(edge);
+        engine.addEdge(edge);
       }
 
       for (const edge of domainEdges) {
-        graph.value.addEdge(edge);
-        const existing = graph.value.getNode(edge.target);
+        engine.addEdge(edge);
+        const existing = engine.getNode(edge.target);
         if (!existing || !existing.loaded) {
-          graph.value.addNode({
+          engine.addNode({
             uri: edge.target,
             register: registerId,
             conceptId: '',
@@ -287,13 +236,10 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         }
       }
 
-      // Ensure edges from all datasets are loaded for cross-dataset supersession
-      await ensureAllEdgesLoaded();
-
       touchGraph();
       conceptEdges.value = [
-        ...graph.value.getEdges(uri),
-        ...graph.value.getIncomingEdges(uri),
+        ...engine.getEdges(uri),
+        ...engine.getIncomingEdges(uri),
       ];
     } catch (e: unknown) {
       error.value = `Failed to load concept ${conceptId}: ${e instanceof Error ? e.message : String(e)}`;
@@ -326,32 +272,46 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
       await discoverDatasets();
     }
 
-    const allHits: SearchHit[] = [];
+    const MIN_RESULTS = 20;
+
+    // Pass 1: search loaded data only
+    const loadedHits: SearchHit[] = [];
+    const unloadedAdapters: DatasetAdapter[] = [];
+
     for (const adapter of datasets.value.values()) {
-      if (adapter.manifest) {
-        if (!adapter.index) {
+      if (!adapter.manifest) continue;
+      if (!adapter.index) {
+        try {
           await adapter.loadIndex();
+        } catch {
+          continue;
         }
-        await adapter.ensureAllChunksLoaded();
-        allHits.push(...adapter.search(query));
+      }
+      const hits = adapter.search(query);
+      if (hits.length > 0) {
+        loadedHits.push(...hits);
+      } else {
+        unloadedAdapters.push(adapter);
       }
     }
 
-    // Deduplicate: keep the best hit per (registerId, conceptId)
-    const best = new Map<string, SearchHit>();
-    for (const hit of allHits) {
-      const key = `${hit.registerId}:${hit.conceptId}`;
-      const existing = best.get(key);
-      if (!existing) {
-        best.set(key, hit);
-      } else {
-        // Prefer designation match over id match, then prefer shorter language code (eng first)
-        if (hit.matchField === 'designation' && existing.matchField === 'id') {
-          best.set(key, hit);
-        }
+    const pass1 = deduplicateSearchHits(loadedHits);
+    if (pass1.length >= MIN_RESULTS) return pass1;
+
+    // Pass 2: load chunks lazily for datasets that found nothing in index
+    let allHits = [...loadedHits];
+    for (const adapter of unloadedAdapters) {
+      if (deduplicateSearchHits(allHits).length >= MIN_RESULTS) break;
+      try {
+        await adapter.ensureAllChunksLoaded();
+        const hits = adapter.search(query);
+        allHits.push(...hits);
+      } catch {
+        // Skip datasets that fail to load
       }
     }
-    return [...best.values()];
+
+    return deduplicateSearchHits(allHits);
   }
 
   async function getRandomConcept(): Promise<{ registerId: string; conceptId: string } | null> {

package/src/utils/index.ts

@@ -1 +1,2 @@
 export { langName, langLabel, DEFAULT_LANG } from './lang';
+export { deduplicateSearchHits } from './search';