@glossarist/concept-browser 0.7.51 → 0.7.53

package/src/components/concept-rdf/sections-builder.ts

@@ -0,0 +1,62 @@
+import type { RdfGraph, RdfResource, RdfTerm } from './rdf-graph';
+
+export interface PropValue {
+  predicate: string;
+  values: string[];
+  nested?: boolean;
+}
+
+export interface ClassInstance {
+  classId: string;
+  classLabel: string;
+  label: string;
+  props: PropValue[];
+}
+
+export function buildSections(graph: RdfGraph): ClassInstance[] {
+  const out: ClassInstance[] = [];
+  for (const r of graph.resources()) {
+    out.push(resourceToSection(r));
+  }
+  return out;
+}
+
+function resourceToSection(r: RdfResource): ClassInstance {
+  const props: PropValue[] = [];
+  const seen = new Set<string>();
+
+  for (const t of r.triples) {
+    const value = formatTerm(t.object);
+    if (!value) continue;
+    const isNested = t.object.kind === 'blank';
+    const key = `${t.predicate}#${isNested ? 'n' : 'f'}#${value}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const prop: PropValue = {
+      predicate: t.predicate,
+      values: [value],
+    };
+    if (isNested) prop.nested = true;
+    props.push(prop);
+  }
+
+  return {
+    classId: r.classId,
+    classLabel: r.classLabel,
+    label: r.label,
+    props,
+  };
+}
+
+export function formatTerm(term: RdfTerm): string {
+  switch (term.kind) {
+    case 'iri':
+      return term.value;
+    case 'literal':
+      return term.value;
+    case 'blank': {
+      const parts = term.triples.map(t => `${t.predicate}: ${formatTerm(t.object)}`);
+      return parts.join('; ');
+    }
+  }
+}

package/src/components/concept-rdf/table-formula-emitter.ts

@@ -0,0 +1,101 @@
+import { GLOSS, DCTERMS, RDF, XSD } from './predicates';
+import { RdfGraph, lit, iri, blank, triple } from './rdf-graph';
+import type { RdfTriple } from './rdf-graph';
+
+export interface FormulaInput {
+  readonly registerId: string;
+  readonly formulaId: string;
+  readonly expression: string;
+  readonly latexForm?: string;
+  readonly description?: string;
+  readonly lang?: string;
+  readonly sourceIri?: string;
+  readonly baseUri?: string;
+}
+
+export interface TableHeaderCell {
+  readonly value: string;
+  readonly lang?: string;
+}
+
+export interface TableRow {
+  readonly cells: readonly string[];
+}
+
+export interface TableInput {
+  readonly registerId: string;
+  readonly tableId: string;
+  readonly title?: string;
+  readonly caption?: string;
+  readonly headers?: readonly TableHeaderCell[];
+  readonly rows?: readonly TableRow[];
+  readonly markup?: string;
+  readonly markupFormat?: string;
+  readonly lang?: string;
+  readonly baseUri?: string;
+}
+
+function base(input: { baseUri?: string }): string {
+  return input.baseUri ?? 'https://glossarist.org';
+}
+
+export function formulaIri(input: FormulaInput): string {
+  return `${base(input)}/${input.registerId}/formula/${input.formulaId}`;
+}
+
+export function tableIri(input: TableInput): string {
+  return `${base(input)}/${input.registerId}/table/${input.tableId}`;
+}
+
+export function emitFormulaGraph(input: FormulaInput): RdfGraph {
+  const graph = new RdfGraph();
+  const iriStr = formulaIri(input);
+  const w = graph.declare(iriStr, {
+    types: [GLOSS.Formula],
+    label: input.expression,
+    classLabel: 'Formula',
+    classId: GLOSS.Formula,
+  });
+  w.literal(GLOSS.expression, input.expression);
+  if (input.latexForm) w.literal(GLOSS.latexForm, input.latexForm);
+  if (input.description) w.literal(DCTERMS.description, input.description, { lang: input.lang });
+  if (input.sourceIri) w.iri('prov:wasDerivedFrom', input.sourceIri);
+  return graph;
+}
+
+export function emitTableGraph(input: TableInput): RdfGraph {
+  const graph = new RdfGraph();
+  const iriStr = tableIri(input);
+  const w = graph.declare(iriStr, {
+    types: [GLOSS.Table],
+    label: input.title ?? input.caption ?? input.tableId,
+    classLabel: 'Table',
+    classId: GLOSS.Table,
+  });
+
+  if (input.title) w.literal(DCTERMS.title, input.title, { lang: input.lang });
+  if (input.caption) w.literal(GLOSS.caption, input.caption, { lang: input.lang });
+
+  if (input.markup != null) {
+    const contentTriples: RdfTriple[] = [
+      triple(RDF.type, iri('gloss:MarkupTable')),
+      triple(GLOSS.content, lit(input.markup)),
+    ];
+    if (input.markupFormat) contentTriples.push(triple(DCTERMS.format, lit(input.markupFormat)));
+    w.blank(GLOSS.content, contentTriples);
+  } else if (input.headers && input.headers.length > 0) {
+    const contentTriples: RdfTriple[] = [
+      triple(RDF.type, iri('gloss:StructuredTable')),
+    ];
+    for (const h of input.headers) {
+      contentTriples.push(triple(GLOSS.hasHeader, lit(h.value, { lang: h.lang ?? input.lang })));
+    }
+    for (const row of input.rows ?? []) {
+      const rowTriples = row.cells.map(c => triple(GLOSS.content, lit(c)));
+      contentTriples.push(triple(GLOSS.hasRow, blank(...rowTriples)));
+    }
+    w.blank(GLOSS.content, contentTriples);
+  }
+
+  return graph;
+}

package/src/components/concept-rdf/turtle-writer.ts

@@ -0,0 +1,116 @@
+import { RDF_PREFIXES } from './rdf-prefixes';
+import type { RdfGraph, RdfResource, RdfTerm, RdfTriple } from './rdf-graph';
+
+const INDENT = '  ';
+
+const ABSOLUTE_SCHEMES = new Set(['http', 'https', 'urn', 'file', 'mailto', 'ftp']);
+
+function isPrefixedName(s: string): boolean {
+  const colonIdx = s.indexOf(':');
+  if (colonIdx < 1) return false;
+  const prefix = s.slice(0, colonIdx);
+  if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(prefix)) return false;
+  if (ABSOLUTE_SCHEMES.has(prefix)) return false;
+  const local = s.slice(colonIdx + 1);
+  return !local.startsWith('//');
+}
+
+function formatIri(value: string): string {
+  if (!isPrefixedName(value)) return `<${value}>`;
+  const colonIdx = value.indexOf(':');
+  const prefix = value.slice(0, colonIdx + 1);
+  const local = value.slice(colonIdx + 1);
+  const escaped = local.replace(/([/])/g, '\\$1');
+  return prefix + escaped;
+}
+
+export function writeTurtle(graph: RdfGraph): string {
+  const lines: string[] = [];
+
+  for (const p of RDF_PREFIXES) {
+    lines.push(`@prefix ${p.prefix}: <${p.iri}> .`);
+  }
+
+  let first = true;
+  for (const r of graph.resources()) {
+    if (first) {
+      lines.push('');
+      first = false;
+    } else {
+      lines.push('');
+    }
+    writeResource(lines, r);
+  }
+
+  return lines.join('\n');
+}
+
+function writeResource(lines: string[], r: RdfResource): void {
+  const subjectForm = formatSubject(r.subject);
+
+  if (r.types.length === 0 && r.triples.length === 0) {
+    lines.push(`${subjectForm} .`);
+    return;
+  }
+
+  if (r.types.length === 0) {
+    const [first, ...rest] = r.triples;
+    lines.push(`${subjectForm} ${first.predicate} ${formatObject(first.object)} ;`);
+    for (const t of rest) {
+      lines.push(`${INDENT}${t.predicate} ${formatObject(t.object)} ;`);
+    }
+    const last = lines.length - 1;
+    lines[last] = lines[last].replace(/ ;$/, ' .');
+    return;
+  }
+
+  const head = `${subjectForm} a ${r.types.join(', ')}`;
+  if (r.triples.length === 0) {
+    lines.push(`${head} .`);
+    return;
+  }
+  lines.push(`${head} ;`);
+  for (const t of r.triples) {
+    lines.push(`${INDENT}${t.predicate} ${formatObject(t.object)} ;`);
+  }
+  const last = lines.length - 1;
+  lines[last] = lines[last].replace(/ ;$/, ' .');
+}
+
+function formatSubject(subject: string): string {
+  return formatIri(subject);
+}
+
+function formatObject(term: RdfTerm): string {
+  switch (term.kind) {
+    case 'iri':
+      return formatIri(term.value);
+    case 'literal':
+      return formatLiteral(term.value, term.lang, term.datatype);
+    case 'blank':
+      return formatBlankNode(term.triples);
+  }
+}
+
+function formatLiteral(value: string, lang?: string, datatype?: string): string {
+  const escaped = escapeLiteral(value);
+  let s = `"${escaped}"`;
+  if (lang) s += `@${lang}`;
+  else if (datatype) s += `^^${datatype}`;
+  return s;
+}
+
+function formatBlankNode(triples: readonly RdfTriple[]): string {
+  if (triples.length === 0) return '[]';
+  const parts = triples.map(t => `${t.predicate} ${formatObject(t.object)}`);
+  return `[ ${parts.join(' ; ')} ]`;
+}
+
+function escapeLiteral(s: string): string {
+  return s
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+}

package/src/components/concept-rdf/use-rdf-document.ts

@@ -0,0 +1,72 @@
+import type { ComputedRef } from 'vue';
+import { computed } from 'vue';
+import type { Concept } from 'glossarist';
+import { getClass } from '../../adapters/ontology-schema';
+import { ConceptIdentity } from '../../adapters/concept-identity';
+import { emitConceptGraph } from './concept-emitter';
+import { writeTurtle } from './turtle-writer';
+import { writeJsonLd } from './jsonld-writer';
+import { buildSections } from './sections-builder';
+import type { ClassInstance, PropValue } from './sections-builder';
+import { decorateWithProvenance, runtimeProvenance } from './provenance';
+
+export type { ClassInstance, PropValue } from './sections-builder';
+
+export interface RdfDocument {
+  sections: ComputedRef<ClassInstance[]>;
+  turtle: ComputedRef<string>;
+  jsonld: ComputedRef<string>;
+  typeChain: ComputedRef<string[]>;
+}
+
+export interface UseRdfDocumentOptions {
+  readonly lazy?: boolean;
+}
+
+const SERIALIZER_VERSION =
+  typeof __CONCEPT_BROWSER_VERSION__ !== 'undefined'
+    ? __CONCEPT_BROWSER_VERSION__
+    : 'dev';
+
+export function useRdfDocument(
+  getConcept: () => Concept,
+  getConceptUri: () => string,
+  _options: UseRdfDocumentOptions = {},
+): RdfDocument {
+  const identity = computed(() => {
+    const concept = getConcept();
+    const uri = getConceptUri();
+    if (ConceptIdentity.isConceptUri(uri)) {
+      const parsed = ConceptIdentity.fromUri(uri);
+      if (parsed.localId === concept.id) return parsed;
+    }
+    return new ConceptIdentity(concept.id, '', '');
+  });
+
+  const safeUri = computed(() => {
+    const uri = getConceptUri();
+    return uri || identity.value.uri;
+  });
+
+  const emission = computed(() => {
+    const result = emitConceptGraph(getConcept(), safeUri.value);
+    decorateWithProvenance(
+      result.graph,
+      safeUri.value,
+      runtimeProvenance(SERIALIZER_VERSION, safeUri.value),
+    );
+    return result;
+  });
+
+  const sections = computed(() => buildSections(emission.value.graph));
+  const turtle = computed(() => writeTurtle(emission.value.graph));
+  const jsonld = computed(() => writeJsonLd(emission.value.graph));
+
+  const typeChain = computed(() => {
+    const conceptCls = getClass('gloss:Concept');
+    if (!conceptCls) return ['owl:Thing', 'skos:Concept', 'gloss:Concept'];
+    return ['owl:Thing', ...conceptCls.ancestors, 'gloss:Concept'];
+  });
+
+  return { sections, turtle, jsonld, typeChain };
+}

package/src/components/concept-rdf/version-emitter.ts

@@ -0,0 +1,65 @@
+import { PROV, DCTERMS, XSD } from './predicates';
+import { RdfGraph, lit, iri, triple } from './rdf-graph';
+
+export interface DatasetVersionInput {
+  readonly registerId: string;
+  readonly version: string;
+  readonly versionIri: string;
+  readonly datasetIri: string;
+  readonly generatedAt: string;
+  readonly previousVersionIri?: string;
+  readonly changeSummary?: string;
+  readonly associatedAgentIri?: string;
+}
+
+export function emitVersionGraph(input: DatasetVersionInput): RdfGraph {
+  const graph = new RdfGraph();
+  const w = graph.declare(input.versionIri, {
+    types: [PROV.Entity],
+    label: `${input.registerId} version ${input.version}`,
+    classLabel: 'Version',
+    classId: PROV.Entity,
+  });
+  w.literal(DCTERMS.isVersionOf, input.datasetIri);
+  if (input.previousVersionIri) {
+    w.iri(PROV.wasRevisionOf, input.previousVersionIri);
+  }
+  w.literal(PROV.generatedAtTime, input.generatedAt, { datatype: XSD.dateTime });
+  if (input.changeSummary) w.literal(DCTERMS.description, input.changeSummary);
+  if (input.associatedAgentIri) w.iri(PROV.wasAssociatedWith, input.associatedAgentIri);
+  return graph;
+}
+
+export interface VersionHistoryEntry {
+  readonly version: string;
+  readonly generatedAt: string;
+  readonly changeSummary?: string;
+}
+
+export interface VersionEmitAllInput {
+  readonly registerId: string;
+  readonly datasetIri: string;
+  readonly versions: readonly VersionHistoryEntry[];
+  readonly associatedAgentIri?: string;
+}
+
+export function emitVersionHistory(input: VersionEmitAllInput): RdfGraph {
+  const graph = new RdfGraph();
+  let previousIri: string | undefined;
+  for (const v of input.versions) {
+    const versionIri = `${input.datasetIri}versions/${v.version}`;
+    const single = emitVersionGraph({
+      registerId: input.registerId,
+      version: v.version,
+      versionIri,
+      datasetIri: input.datasetIri,
+      generatedAt: v.generatedAt,
+      previousVersionIri: previousIri,
+      changeSummary: v.changeSummary,
+      associatedAgentIri: input.associatedAgentIri,
+    });
+    graph.merge(single);
+    previousIri = versionIri;
+  }
+  return graph;
+}

package/src/components/concept-rdf/vocabulary-emitter.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SKOS } from './predicates';
+import { RdfGraph } from './rdf-graph';
+import type { RdfGraph as RdfGraphType } from './rdf-graph';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VOCAB_PATH = join(__dirname, '..', '..', '..', 'data', 'glossarist-vocab.json');
+
+export interface VocabTerm {
+  readonly iri: string;
+  readonly label: string;
+  readonly group?: string;
+}
+
+export interface VocabScheme {
+  readonly schemeIri: string;
+  readonly label: string;
+  readonly terms: readonly VocabTerm[];
+}
+
+interface VocabFile {
+  readonly schemes: readonly VocabScheme[];
+}
+
+let cached: VocabFile | undefined;
+
+export function loadVocabulary(path: string = VOCAB_PATH): VocabFile {
+  if (cached && path === VOCAB_PATH) return cached;
+  const text = readFileSync(path, 'utf8');
+  cached = JSON.parse(text) as VocabFile;
+  return cached;
+}
+
+export const VOCAB_SCHEMES: readonly VocabScheme[] = loadVocabulary().schemes;
+
+export function emitVocabularyGraph(graph: RdfGraphType = new RdfGraph()): RdfGraphType {
+  for (const scheme of VOCAB_SCHEMES) {
+    const schemeW = graph.declare(scheme.schemeIri, {
+      types: [SKOS.ConceptScheme],
+      label: scheme.label,
+      classLabel: 'ConceptScheme',
+      classId: SKOS.ConceptScheme,
+    });
+    for (const term of scheme.terms) {
+      const termW = graph.declare(term.iri, {
+        types: [SKOS.Concept],
+        label: term.label,
+        classLabel: 'Concept',
+        classId: SKOS.Concept,
+      });
+      termW.iri(SKOS.inScheme, scheme.schemeIri);
+      schemeW.iri(SKOS.hasTopConcept, term.iri);
+    }
+  }
+  return graph;
+}
+
+export function listVocabSchemes(): readonly VocabScheme[] {
+  return VOCAB_SCHEMES;
+}

package/src/components/groups/DatasetGroupRenderer.vue

@@ -0,0 +1,32 @@
+<script setup lang="ts">
+/**
+ * DatasetGroupRenderer — OCP dispatcher. Maps group.kind to the
+ * appropriate sidebar renderer component. New kinds: add entry to
+ * GROUP_RENDERERS + new component. Zero edits to existing code.
+ */
+import { computed } from 'vue';
+import { groupRendererFor } from '../../config/group-renderers';
+import { resolveGroupKind } from '../../config/group-types';
+import type { DatasetGroupKind } from '../../config/types';
+
+const props = defineProps<{
+  kind: DatasetGroupKind;
+  entries: Array<{
+    id: string;
+    title: string;
+    ref?: string;
+    loaded: boolean;
+    conceptCount: number;
+    year?: number;
+    status?: string;
+    isCurrent?: boolean;
+  }>;
+  currentDataset: string;
+}>();
+
+const renderer = computed(() => groupRendererFor(resolveGroupKind({ kind: props.kind })).sidebar);
+</script>
+
+<template>
+  <component :is="renderer" :entries="entries" :current-dataset="currentDataset" />
+</template>

package/src/components/groups/DefaultGroupSidebar.vue

@@ -0,0 +1,50 @@
+<script setup lang="ts">
+/**
+ * DefaultGroupSidebar — flat list of dataset entries with expansion.
+ * Used for topic, family, collection, and default group kinds.
+ * Replaces the inline v-else template in AppSidebar.
+ */
+import { useRouter } from 'vue-router';
+import { useI18n } from '../../i18n';
+
+const props = defineProps<{
+  entries: Array<{
+    id: string;
+    title: string;
+    loaded: boolean;
+    conceptCount: number;
+  }>;
+  currentDataset: string;
+}>();
+
+const router = useRouter();
+const { t } = useI18n();
+
+function navigate(id: string) {
+  if (id === props.currentDataset) return;
+  router.push({ name: 'dataset', params: { registerId: id } });
+}
+</script>
+
+<template>
+  <div
+    v-for="ds in entries"
+    :key="ds.id"
+    class="rounded-lg transition-all duration-150"
+    :class="currentDataset === ds.id ? 'bg-surface' : ''"
+  >
+    <button
+      type="button"
+      class="w-full text-left px-3 py-2 rounded-lg text-sm border-l-2"
+      :class="currentDataset === ds.id
+        ? 'text-ink-800 dark:text-ink-50'
+        : 'border-transparent text-ink-600 dark:text-ink-300 hover:bg-ink-50 dark:hover:bg-ink-700 hover:text-ink-800 dark:hover:text-ink-50'"
+      @click="navigate(ds.id)"
+    >
+      <div class="font-medium truncate leading-snug">{{ ds.title }}</div>
+      <div v-if="ds.loaded" class="text-xs mt-0.5 text-ink-300 dark:text-ink-400">
+        {{ ds.conceptCount.toLocaleString() }} {{ t('home.concepts').toLowerCase() }}
+      </div>
+    </button>
+  </div>
+</template>

package/src/components/groups/LineageGroupSidebar.vue

@@ -0,0 +1,75 @@
+<script setup lang="ts">
+/**
+ * LineageGroupSidebar — timeline-style entries for edition series.
+ * Replaces the inline v-if="group.kind === 'lineage'" template in
+ * AppSidebar. Open/closed: new group kinds get their own component.
+ */
+import { useRouter } from 'vue-router';
+
+const props = defineProps<{
+  entries: Array<{
+    id: string;
+    title: string;
+    ref?: string;
+    loaded: boolean;
+    conceptCount: number;
+    year?: number;
+    status?: string;
+    isCurrent?: boolean;
+  }>;
+  currentDataset: string;
+}>();
+
+const router = useRouter();
+
+function navigate(id: string) {
+  if (id === props.currentDataset) return;
+  router.push({ name: 'dataset', params: { registerId: id } });
+}
+</script>
+
+<template>
+  <div class="series-timeline">
+    <button
+      v-for="ds in entries"
+      :key="ds.id"
+      type="button"
+      class="series-entry w-full text-left flex items-center gap-2 pl-6 pr-3 py-1.5 rounded-md text-sm border-l-2 transition-all duration-150"
+      :class="currentDataset === ds.id
+        ? 'bg-amber-50/70 dark:bg-amber-400/10 border-l-[3px] text-ink-900 dark:text-ink-50 font-semibold'
+        : 'border-transparent text-ink-600 dark:text-ink-300 hover:bg-ink-50 dark:hover:bg-ink-700/40 hover:text-ink-900 dark:hover:text-ink-50'"
+      :style="currentDataset === ds.id ? { borderLeftColor: 'var(--group-kind-lineage-light, #B8935A)' } : {}"
+      @click="navigate(ds.id)"
+    >
+      <span class="flex-1 truncate text-[13.5px] font-medium leading-snug">{{ ds.ref || ds.title || ds.id }}</span>
+      <span
+        v-if="ds.status && ds.status !== 'valid'"
+        class="text-[9px] uppercase tracking-wide italic text-ink-400 dark:text-ink-400"
+      >{{ ds.status }}</span>
+      <span
+        v-if="ds.isCurrent"
+        class="current-star flex-shrink-0"
+        title="Current edition"
+      >✦</span>
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.series-entry {
+  position: relative;
+}
+.current-star {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 16px;
+  line-height: 1;
+  color: var(--group-kind-lineage-light, #B8935A);
+  filter: drop-shadow(0 0 4px rgba(184, 147, 90, 0.45));
+}
+:global(.dark) .current-star {
+  color: var(--group-kind-lineage-dark, #D4AF6E);
+  filter: drop-shadow(0 0 4px rgba(212, 175, 110, 0.55));
+}
+</style>