@glossarist/concept-browser 0.1.0

package/src/config/use-site-config.ts

@@ -0,0 +1,144 @@
+import { ref, computed } from 'vue';
+import type { PageConfig } from './types';
+
+export interface RuntimeSiteConfig {
+  id: string;
+  domain: string;
+  title: string;
+  subtitle?: string;
+  description?: string;
+  datasets: string[];
+  defaultDataset?: string;
+  branding?: {
+    primaryColor?: string;
+    darkColor?: string;
+    fonts?: {
+      header?: { family: string; source: string; weights?: number[]; url?: string };
+      body?: { family: string; source: string; weights?: number[]; url?: string };
+    };
+    logo?: { path: string; alt: string; url?: string };
+    footerLogo?: { path: string; alt: string; url?: string };
+    ownerName?: string;
+    ownerUrl?: string;
+  };
+  analytics?: { googleAnalyticsId?: string };
+  features?: Record<string, unknown>;
+  social?: Record<string, string>;
+  nav?: { label: string; route: string }[];
+  footerNav?: { label: string; route: string }[];
+  defaults?: { language?: string; languageOrder?: string[] };
+  email?: string;
+  pages?: PageConfig[];
+}
+
+const siteConfig = ref<RuntimeSiteConfig | null>(null);
+const loaded = ref(false);
+
+function loadFont(font: { family: string; source: string; weights?: number[]; url?: string }) {
+  if (font.source === 'google') {
+    const w = (font.weights || [400, 700]).join(';');
+    const href = `https://fonts.googleapis.com/css2?family=${font.family.replace(/ /g, '+')}:wght@${w}&display=swap`;
+    const existing = document.querySelector(`link[href="${href}"]`);
+    if (existing) return;
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = href;
+    document.head.appendChild(link);
+  }
+  if (font.source === 'url' && font.url) {
+    const existing = document.querySelector(`link[href="${font.url}"]`);
+    if (existing) return;
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = font.url;
+    document.head.appendChild(link);
+  }
+}
+
+function hexToRgb(hex: string): [number, number, number] {
+  const h = hex.replace('#', '');
+  return [
+    parseInt(h.substring(0, 2), 16),
+    parseInt(h.substring(2, 4), 16),
+    parseInt(h.substring(4, 6), 16),
+  ];
+}
+
+function applyBranding(config: RuntimeSiteConfig) {
+  const root = document.documentElement;
+  const b = config.branding;
+  if (!b) return;
+
+  if (b.primaryColor) {
+    root.style.setProperty('--brand-primary', b.primaryColor);
+    const [r, g, bl] = hexToRgb(b.primaryColor);
+    root.style.setProperty('--brand-primary-rgb', `${r}, ${g}, ${bl}`);
+  }
+  if (b.darkColor) {
+    root.style.setProperty('--brand-dark', b.darkColor);
+  }
+
+  if (b.fonts?.header) {
+    loadFont(b.fonts.header);
+    root.style.setProperty('--font-header', `'${b.fonts.header.family}', Georgia, serif`);
+  }
+  if (b.fonts?.body) {
+    loadFont(b.fonts.body);
+    root.style.setProperty('--font-body', `'${b.fonts.body.family}', system-ui, sans-serif`);
+  }
+}
+
+async function loadConfig(): Promise<RuntimeSiteConfig | null> {
+  if (loaded.value) return siteConfig.value;
+  try {
+    const resp = await fetch('/site-config.json');
+    if (resp.ok) {
+      siteConfig.value = await resp.json();
+      if (siteConfig.value) applyBranding(siteConfig.value);
+    }
+  } catch {
+    // Non-critical
+  }
+  loaded.value = true;
+  return siteConfig.value;
+}
+
+const BUILTIN_GLOBAL_PAGES: PageConfig[] = [
+  { type: 'custom', route: '', title: 'Home', icon: 'home' },
+  { type: 'custom', route: 'search', title: 'Search', icon: 'search' },
+  { type: 'custom', route: 'graph', title: 'Graph', icon: 'graph' },
+];
+
+const BUILTIN_DATASET_PAGES: PageConfig[] = [
+  { type: 'custom', route: '', title: 'Concepts', icon: 'list' },
+  { type: 'stats', route: 'stats', title: 'Statistics', icon: 'chart' },
+  { type: 'about', route: 'about', title: 'About', icon: 'info' },
+];
+
+function synthesizePages(features?: Record<string, unknown>, pages?: PageConfig[]) {
+  if (pages && pages.length > 0) return pages;
+
+  const result = [...BUILTIN_GLOBAL_PAGES];
+  if (features?.news) {
+    result.push({ type: 'news', route: 'news', title: 'News', icon: 'newspaper' });
+  }
+  return result;
+}
+
+export function useSiteConfig() {
+  const config = computed(() => siteConfig.value);
+  const visibleDatasets = computed(() => siteConfig.value?.datasets ?? []);
+
+  const globalPages = computed<PageConfig[]>(() =>
+    synthesizePages(siteConfig.value?.features, siteConfig.value?.pages)
+      .filter(p => !p.datasetScoped),
+  );
+
+  const datasetPages = computed<PageConfig[]>(() => {
+    const declared = siteConfig.value?.pages?.filter(p => p.datasetScoped) ?? [];
+    if (declared.length > 0) return declared;
+    return BUILTIN_DATASET_PAGES;
+  });
+
+  return { config, visibleDatasets, loadConfig, globalPages, datasetPages };
+}

package/src/graph/GraphEngine.ts

@@ -0,0 +1,137 @@
+import type { GraphNode, GraphEdge } from '../adapters/types';
+import { UriRouter } from '../adapters/UriRouter';
+
+/**
+ * Directed multigraph engine for concept relationships.
+ * Supports cross-register edges with stub nodes for unresolved targets.
+ */
+export class GraphEngine {
+  private nodes = new Map<string, GraphNode>();
+  private edges: GraphEdge[] = [];
+  private edgeKeys = new Set<string>();
+  private adjacency = new Map<string, Map<string, GraphEdge[]>>();
+  private reverseAdjacency = new Map<string, Map<string, GraphEdge[]>>();
+
+  addNode(node: GraphNode): void {
+    const existing = this.nodes.get(node.uri);
+    if (!existing) {
+      this.nodes.set(node.uri, node);
+    } else if (node.loaded && !existing.loaded) {
+      this.nodes.set(node.uri, node);
+    }
+  }
+
+  addEdge(edge: GraphEdge): void {
+    const key = `${edge.source}\0${edge.target}\0${edge.type}`;
+    if (this.edgeKeys.has(key)) return;
+    this.edgeKeys.add(key);
+
+    const parsed = UriRouter.parseUri(edge.target);
+    if (!this.nodes.has(edge.source)) {
+      const sourceParsed = UriRouter.parseUri(edge.source);
+      this.nodes.set(edge.source, {
+        uri: edge.source,
+        register: sourceParsed?.registerId ?? edge.register,
+        conceptId: sourceParsed?.conceptId ?? '',
+        designations: {},
+        status: 'stub',
+        loaded: false,
+      });
+    }
+    if (!this.nodes.has(edge.target)) {
+      this.nodes.set(edge.target, {
+        uri: edge.target,
+        register: parsed?.registerId ?? '',
+        conceptId: parsed?.conceptId ?? '',
+        designations: {},
+        status: 'stub',
+        loaded: false,
+      });
+    }
+
+    this.edges.push(edge);
+
+    if (!this.adjacency.has(edge.source)) this.adjacency.set(edge.source, new Map());
+    const sourceAdj = this.adjacency.get(edge.source)!;
+    if (!sourceAdj.has(edge.target)) sourceAdj.set(edge.target, []);
+    sourceAdj.get(edge.target)!.push(edge);
+
+    if (!this.reverseAdjacency.has(edge.target)) this.reverseAdjacency.set(edge.target, new Map());
+    const targetAdj = this.reverseAdjacency.get(edge.target)!;
+    if (!targetAdj.has(edge.source)) targetAdj.set(edge.source, []);
+    targetAdj.get(edge.source)!.push(edge);
+  }
+
+  getNode(uri: string): GraphNode | undefined {
+    return this.nodes.get(uri);
+  }
+
+  getEdges(from?: string): GraphEdge[] {
+    if (from) {
+      const adj = this.adjacency.get(from);
+      if (!adj) return [];
+      return [...adj.values()].flat();
+    }
+    return this.edges;
+  }
+
+  getIncomingEdges(uri: string): GraphEdge[] {
+    const adj = this.reverseAdjacency.get(uri);
+    if (!adj) return [];
+    return [...adj.values()].flat();
+  }
+
+  getNeighbors(uri: string): { outgoing: string[]; incoming: string[] } {
+    const outgoing: string[] = [];
+    const adj = this.adjacency.get(uri);
+    if (adj) for (const target of adj.keys()) outgoing.push(target);
+
+    const incoming: string[] = [];
+    const radj = this.reverseAdjacency.get(uri);
+    if (radj) for (const source of radj.keys()) incoming.push(source);
+
+    return { outgoing, incoming };
+  }
+
+  getSubgraph(rootUri: string, depth: number = 2): { nodes: GraphNode[]; edges: GraphEdge[] } {
+    const visited = new Set<string>();
+    const collectedNodes: GraphNode[] = [];
+    const collectedEdges: GraphEdge[] = [];
+    const queue: { uri: string; d: number }[] = [{ uri: rootUri, d: 0 }];
+
+    while (queue.length > 0) {
+      const { uri, d } = queue.shift()!;
+      if (visited.has(uri) || d > depth) continue;
+      visited.add(uri);
+
+      const node = this.nodes.get(uri);
+      if (node) collectedNodes.push(node);
+
+      const outEdges = this.getEdges(uri);
+      for (const e of outEdges) {
+        collectedEdges.push(e);
+        if (!visited.has(e.target)) queue.push({ uri: e.target, d: d + 1 });
+      }
+
+      const inEdges = this.getIncomingEdges(uri);
+      for (const e of inEdges) {
+        collectedEdges.push(e);
+        if (!visited.has(e.source)) queue.push({ uri: e.source, d: d + 1 });
+      }
+    }
+
+    return { nodes: collectedNodes, edges: collectedEdges };
+  }
+
+  getAllNodes(): GraphNode[] {
+    return [...this.nodes.values()];
+  }
+
+  get nodeCount(): number {
+    return this.nodes.size;
+  }
+
+  get edgeCount(): number {
+    return this.edges.length;
+  }
+}

package/src/graph/index.ts

@@ -0,0 +1 @@
+export { GraphEngine } from './GraphEngine';

package/src/main.ts

@@ -0,0 +1,11 @@
+import { createApp } from 'vue';
+import { createPinia } from 'pinia';
+import App from './App.vue';
+import router from './router';
+import 'katex/dist/katex.min.css';
+import './style.css';
+
+const app = createApp(App);
+app.use(createPinia());
+app.use(router);
+app.mount('#app');

package/src/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":__tests__/data-integrity.test.ts",{"duration":578.8590829999999,"failed":false}],[":__tests__/graph.test.ts",{"duration":3.8173329999999623,"failed":false}],[":__tests__/uri-router.test.ts",{"duration":2.3697500000000105,"failed":false}],[":__tests__/dataset-adapter.test.ts",{"duration":5.140625,"failed":false}],[":__tests__/data-integration.test.ts",{"duration":3.391625000000033,"failed":false}]]}

package/src/router/index.ts

@@ -0,0 +1,43 @@
+import { createRouter, createWebHistory, type RouteRecordRaw } from 'vue-router';
+
+const routes: RouteRecordRaw[] = [
+  {
+    path: '/',
+    name: 'home',
+    component: () => import('../views/HomeView.vue'),
+  },
+  {
+    path: '/dataset/:registerId',
+    name: 'dataset',
+    component: () => import('../views/DatasetView.vue'),
+    props: true,
+  },
+  {
+    path: '/dataset/:registerId/concept/:conceptId',
+    name: 'concept',
+    component: () => import('../views/ConceptView.vue'),
+    props: true,
+  },
+  {
+    path: '/search',
+    name: 'search',
+    component: () => import('../views/SearchView.vue'),
+  },
+  {
+    path: '/graph',
+    name: 'graph',
+    component: () => import('../views/GraphView.vue'),
+  },
+  {
+    path: '/resolve/:uri(.*)',
+    name: 'resolve',
+    component: () => import('../views/ResolveView.vue'),
+  },
+];
+
+const router = createRouter({
+  history: createWebHistory(import.meta.env.BASE_URL),
+  routes,
+});
+
+export default router;

package/src/router/page-routes.ts

@@ -0,0 +1,35 @@
+import type { RouteRecordRaw } from 'vue-router';
+import type { PageConfig } from '../config/types';
+
+const pageComponents: Record<string, () => Promise<any>> = {
+  news: () => import('../views/NewsView.vue'),
+  contributors: () => import('../views/ContributorsView.vue'),
+  about: () => import('../views/AboutView.vue'),
+  stats: () => import('../views/StatsView.vue'),
+};
+
+export function buildPageRoutes(pages: PageConfig[]): RouteRecordRaw[] {
+  const routes: RouteRecordRaw[] = [];
+
+  for (const page of pages) {
+    const component = pageComponents[page.type];
+    if (!component) continue;
+
+    if (page.datasetScoped) {
+      routes.push({
+        path: `/dataset/:registerId/${page.route}`,
+        name: page.route,
+        component,
+        props: true,
+      });
+    } else {
+      routes.push({
+        path: `/${page.route}`,
+        name: page.route,
+        component,
+      });
+    }
+  }
+
+  return routes;
+}

package/src/stores/ui.ts

@@ -0,0 +1,59 @@
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+
+export type Theme = 'light' | 'dark' | 'system';
+
+function getSystemDark(): boolean {
+  return window.matchMedia('(prefers-color-scheme: dark)').matches;
+}
+
+function getStoredTheme(): Theme {
+  return (localStorage.getItem('theme') as Theme) || 'system';
+}
+
+export const useUiStore = defineStore('ui', () => {
+  const sidebarOpen = ref(false);
+  const selectedLang = ref('eng');
+  const searchQuery = ref('');
+  const showGraphPanel = ref(false);
+  const themePref = ref<Theme>(getStoredTheme());
+
+  const isDark = computed(() => {
+    return themePref.value === 'dark' || (themePref.value === 'system' && getSystemDark());
+  });
+
+  function applyTheme() {
+    document.documentElement.classList.toggle('dark', isDark.value);
+  }
+
+  function setTheme(t: Theme) {
+    themePref.value = t;
+    localStorage.setItem('theme', t);
+    applyTheme();
+  }
+
+  function toggleTheme() {
+    if (isDark.value) {
+      setTheme('light');
+    } else {
+      setTheme('dark');
+    }
+  }
+
+  function toggleSidebar() {
+    sidebarOpen.value = !sidebarOpen.value;
+  }
+
+  function setLang(lang: string) {
+    selectedLang.value = lang;
+  }
+
+  // Apply on creation
+  applyTheme();
+  // React to system preference changes
+  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+    if (themePref.value === 'system') applyTheme();
+  });
+
+  return { sidebarOpen, selectedLang, searchQuery, showGraphPanel, themePref, isDark, toggleSidebar, setLang, setTheme, toggleTheme };
+});