@glossarist/concept-browser 0.7.112 → 0.7.113

package/package.json

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

package/src/__tests__/composables/cite-resolver.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { computed, ref } from 'vue';
+import { useConceptEdges } from '../../composables/use-concept-edges';
+import { useVocabularyStore } from '../../stores/vocabulary';
+import type { Manifest, GraphEdge } from '../../adapters/types';
+import { makeManifest, setupPinia } from '../test-helpers';
+import { getFactory, resetFactory } from '../../adapters/factory';
+import { useRenderOptions } from '../../composables/use-render-options';
+import type { Router } from 'vue-router';
+
+/**
+ * citeResolver contract — pins the {{cite:sourceId}} resolution cascade.
+ *
+ * The citeResolver must:
+ * 1. Look up the concept's own sources[] for a matching id
+ * 2. Delegate to ReferenceResolver.resolveCite() which walks the
+ *    deployment's cascade
+ * 3. Render based on classification (internal → navigable link,
+ *    self-contained → external link with origin.link, unresolved → span)
+ *
+ * Bug history: citeResolver was dead code (never wired). Every
+ * {{cite:foo}} mention fell through to a plain <span> with no resolution.
+ * This spec pins the wiring.
+ */
+
+describe('citeResolver — {{cite:sourceId}} resolution', () => {
+  const noopRouter = { push() {} } as unknown as Router;
+  let store: ReturnType<typeof useVocabularyStore>;
+  const manifest: Manifest = makeManifest({
+    id: 'test',
+    datasetUri: 'urn:test:dataset',
+    uriBase: 'https://example.org',
+  });
+
+  beforeEach(() => {
+    setupPinia();
+    resetFactory();
+    store = useVocabularyStore();
+    store.manifests.set(manifest.id, manifest);
+
+    const factory = getFactory();
+    factory.resolveRelatedRef = vi.fn((ref: { source: string | null; id: string | null } | null) =>
+      ref?.source === 'urn:test:dataset' && ref.id
+        ? { registerId: manifest.id, conceptId: ref.id }
+        : null,
+    );
+  });
+
+  it('returns cite-ref span when no sources are provided', () => {
+    const { citeResolver } = useRenderOptions(() => 'test', () => undefined);
+    const html = citeResolver('foo', null);
+    expect(html).toContain('cite-ref');
+    expect(html).toContain('foo');
+  });
+
+  it('returns cite-unresolved when source id not found in sources', () => {
+    const sources = [{ id: 'bar', origin: { ref: { source: 'Test', id: '42' } } }];
+    const { citeResolver } = useRenderOptions(() => 'test', () => sources);
+    const html = citeResolver('foo', null);
+    expect(html).toContain('cite-unresolved');
+    expect(html).toContain('foo');
+  });
+
+  it('renders the label when provided', () => {
+    const sources = [{ id: 'foo', origin: { ref: { source: 'Test', id: '42' } } }];
+    const { citeResolver } = useRenderOptions(() => 'test', () => sources);
+    const html = citeResolver('foo', 'custom label');
+    // The resolver runs the cascade. Without a registered sourceRef, it
+    // falls through to unresolved or self-contained. Either way, the label
+    // or the source info should be in the output.
+    expect(html).toMatch(/custom label|Test|42/);
+  });
+
+  it('renders origin.link as external link for self-contained citation', () => {
+    const link = 'https://example.org/external/page';
+    const sources = [{
+      id: 'foo',
+      origin: { ref: { source: 'External', id: 'X1' }, link },
+    }];
+    const { citeResolver } = useRenderOptions(() => 'test', () => sources);
+    const html = citeResolver('foo', null);
+    // Without a registered sourceRef matching "External", the cascade
+    // falls through to self-contained or external. The link should appear.
+    expect(html).toContain('href');
+    expect(html).toContain(link);
+  });
+
+  it('does NOT crash when source.origin is null', () => {
+    const sources = [{ id: 'foo', origin: null }];
+    const { citeResolver } = useRenderOptions(() => 'test', () => sources);
+    expect(() => citeResolver('foo', null)).not.toThrow();
+  });
+
+  it('does NOT crash when sources is empty array', () => {
+    const { citeResolver } = useRenderOptions(() => 'test', () => []);
+    expect(() => citeResolver('foo', null)).not.toThrow();
+  });
+
+  it('does NOT crash when registerId returns empty string', () => {
+    const sources = [{ id: 'foo', origin: { ref: { source: 'X', id: '1' } } }];
+    const { citeResolver } = useRenderOptions(() => '', () => sources);
+    expect(() => citeResolver('foo', null)).not.toThrow();
+  });
+});
+
+describe('RenderOptions — urnRefResolver removed', () => {
+  it('content-renderer no longer exports UrnRefResolver type', async () => {
+    // RenderOptions is a TypeScript interface (no runtime export).
+    // Verify the UrnRefResolver type is gone by checking the source.
+    const fs = await import('fs');
+    const path = await import('path');
+    const source = fs.readFileSync(
+      path.resolve(process.cwd(), 'src/utils/content-renderer.ts'),
+      'utf-8',
+    );
+    expect(source).not.toMatch(/UrnRefResolver/);
+    expect(source).not.toMatch(/urnRefResolver/);
+  });
+});

package/src/components/ConceptDetail.vue

@@ -117,9 +117,14 @@ const conceptSources = computed(() => props.concept?.sources ?? []);
 const conceptTags = computed(() => props.concept?.tags ?? []);
 
 const factory = getFactory();
-const { ensureBibLoaded, bibResolver, nonVerbalRefResolver } = useRenderOptions(() => props.registerId);
+const { ready: bibReady, ensureBibLoaded, bibResolver, citeResolver, nonVerbalRefResolver } = useRenderOptions(
+  () => props.registerId,
+  () => props.concept?.sources,
+);
 
-const renderOpts = computed<RenderOptions>(() => ({
+const renderOpts = computed<RenderOptions>(() => {
+  bibReady.value;
+  return {
   xrefResolver: (uri, term) => {
     const resolution = factory.resolve(uri, props.registerId);
     if (resolution.type === 'internal') {
@@ -139,8 +144,10 @@ const renderOpts = computed<RenderOptions>(() => ({
     return `<a href="#" class="xref-link" data-register="${escapeAttr(props.registerId)}" data-concept="${escapeAttr(resolvedId)}">${escapeAttr(term)}</a>`;
   },
   bibResolver,
+  citeResolver,
   nonVerbalRefResolver,
-}));
+};
+});
 
 watch(() => props.registerId, () => { ensureBibLoaded(); }, { immediate: true });
 
@@ -152,7 +159,7 @@ const structuralEntityRefs = useConceptEntities(
 useNonVerbalCrossRef();
 
 function handleContentClick(e: MouseEvent) {
-  const target = (e.target as HTMLElement).closest('.xref-link') as HTMLElement | null;
+  const target = (e.target as HTMLElement).closest('.xref-link, .cite-link') as HTMLElement | null;
   if (!target) return;
   e.preventDefault();
   const registerId = target.dataset.register;

package/src/composables/use-render-options.ts

@@ -1,11 +1,34 @@
-import { ref } from 'vue';
-import type { RenderOptions, BibResolver, NonVerbalRefResolver } from '../utils/content-renderer';
+/**
+ * Render-options composable — builds resolvers for the content renderer.
+ *
+ * The citeResolver is the load-bearing addition: it connects inline
+ * {{cite:sourceId}} mentions to the existing ReferenceResolver cascade
+ * (factory.resolver.resolveCite). This closes the data/deployment
+ * boundary: the data author writes {{cite:iev_702-02-07}}, the resolver
+ * walks the deployment's sourceRefs → routing → link cascade, and the
+ * renderer emits the correct HTML based on classification.
+ */
+import { ref, type Ref } from 'vue';
+import type { RenderOptions, BibResolver, CiteResolver, NonVerbalRefResolver } from '../utils/content-renderer';
 import type { NonVerbalKind } from '../adapters/non-verbal/types';
 import { getFactory } from '../adapters/factory';
 import { anchorId } from '../utils/non-verbal-anchor';
-import { escapeAttr } from '../utils/escape';
+import { escapeAttr, escapeHtml } from '../utils/escape';
 
-export function useRenderOptions(registerId: () => string) {
+/** Minimal shape of a ConceptSource that citeResolver needs. */
+interface ConceptSourceLike {
+  id?: string | null;
+  origin?: {
+    ref?: { source?: string | null; id?: string | null; version?: string | null } | null;
+    locality?: { type?: string | null; reference_from?: string | null; referenceTo?: string | null; reference_to?: string | null; referenceFrom?: string | null } | null;
+    link?: string | null;
+  } | null;
+}
+
+export function useRenderOptions(
+  registerId: () => string,
+  getSources?: () => readonly ConceptSourceLike[] | undefined,
+) {
   const ready = ref(false);
 
   async function ensureBibLoaded() {
@@ -19,28 +42,80 @@ export function useRenderOptions(registerId: () => string) {
     const id = registerId();
     const entry = id ? getFactory().bibliography(id).findById(refId) : null;
     if (!entry) {
-      return `<span class="bib-ref">${escapeAttr(title)}</span>`;
+      return `<span class="bib-ref">${escapeHtml(title)}</span>`;
     }
     const display = title || entry.reference || refId;
     if (entry.link) {
-      return `<a href="${escapeAttr(entry.link)}" target="_blank" rel="noopener" class="bib-link" title="${escapeAttr(entry.title ?? '')}">${escapeAttr(display)}</a>`;
+      return `<a href="${escapeAttr(entry.link)}" target="_blank" rel="noopener" class="bib-link" title="${escapeAttr(entry.reference ?? '')}">${escapeHtml(display)}</a>`;
+    }
+    return `<span class="bib-ref" title="${escapeAttr(entry.reference ?? '')}">${escapeHtml(display)}</span>`;
+  };
+
+  /**
+   * citeResolver — the canonical path for {{cite:sourceId}} mentions.
+   *
+   * Looks up the concept's own sources[] for a matching id, then
+   * delegates to ReferenceResolver.resolveCite() which walks the
+   * deployment's cascade (sourceRefs → routing → link → unresolved).
+   */
+  const citeResolver: CiteResolver = (key, label) => {
+    const rid = registerId();
+    const sources = getSources?.();
+    if (!sources || !rid) {
+      return `<span class="cite-ref">${escapeHtml(label ?? key)}</span>`;
+    }
+
+    const source = sources.find(s => s.id === key);
+    if (!source?.origin) {
+      return `<span class="cite-unresolved">${escapeHtml(label ?? key)}</span>`;
+    }
+
+    const factory = getFactory();
+    const resolution = factory.resolver.resolveCite(source.origin, rid);
+    const refId = source.origin.ref?.id ?? key;
+    const refSource = source.origin.ref?.source ?? '';
+    const display = label ?? refId;
+
+    switch (resolution.classification) {
+      case 'internal-citation': {
+        if (!resolution.resolved) break;
+        const { registerId: targetReg, conceptId } = resolution.resolved;
+        const isCross = targetReg !== rid;
+        const crossBadge = isCross ? '<span class="text-[9px] opacity-60">↗</span>' : '';
+        return `<a href="#" class="cite-link" data-register="${escapeAttr(targetReg)}" data-concept="${escapeAttr(conceptId)}">${escapeHtml(display)} ${crossBadge}</a>`;
+      }
+      case 'self-contained-citation': {
+        const link = source.origin.link;
+        if (link) {
+          return `<a href="${escapeAttr(link)}" target="_blank" rel="noopener" class="cite-link cite-external">${escapeHtml(refSource || display)} <span class="text-[9px] opacity-60">↗</span></a>`;
+        }
+        return `<span class="cite-ref">${escapeHtml(refSource || display)}</span>`;
+      }
+      case 'external-citation': {
+        const link = source.origin.link;
+        if (link) {
+          return `<a href="${escapeAttr(link)}" target="_blank" rel="noopener" class="cite-link cite-external">${escapeHtml(refSource || display)} <span class="text-[9px] opacity-60">↗</span></a>`;
+        }
+        return `<span class="cite-ref">${escapeHtml(refSource || display)}</span>`;
+      }
     }
-    return `<span class="bib-ref" title="${escapeAttr(entry.title ?? '')}">${escapeAttr(display)}</span>`;
+
+    return `<span class="cite-unresolved">${escapeHtml(display)}</span>`;
   };
 
   const nonVerbalRefResolver: NonVerbalRefResolver = (kind: NonVerbalKind, entityId, display) => {
     const id = registerId();
     if (!id) {
       const label = display ?? entityId;
-      return `<span class="nv-ref nv-ref--${kind}">${escapeAttr(label)}</span>`;
+      return `<span class="nv-ref nv-ref--${kind}">${escapeHtml(label)}</span>`;
     }
     const href = `#${anchorId(kind, id, entityId)}`;
     const label = display ?? defaultLabelForKind(kind, entityId);
     const cls = `nv-ref nv-ref--${kind}`;
-    return `<a href="${href}" class="${cls}" data-nv-kind="${escapeAttr(kind)}" data-nv-dataset="${escapeAttr(id)}" data-nv-entity="${escapeAttr(entityId)}">${escapeAttr(label)}</a>`;
+    return `<a href="${href}" class="${cls}" data-nv-kind="${escapeAttr(kind)}" data-nv-dataset="${escapeAttr(id)}" data-nv-entity="${escapeAttr(entityId)}">${escapeHtml(label)}</a>`;
   };
 
-  return { ready, ensureBibLoaded, bibResolver, nonVerbalRefResolver };
+  return { ready, ensureBibLoaded, bibResolver, citeResolver, nonVerbalRefResolver };
 }
 
 function defaultLabelForKind(kind: NonVerbalKind, entityId: string): string {
@@ -50,3 +125,6 @@ function defaultLabelForKind(kind: NonVerbalKind, entityId: string): string {
     case 'formula': return `Formula ${entityId}`;
   }
 }
+
+/** Ensure `ready` is tracked as a Ref for consumers that read `.value`. */
+export type RenderOptionsReady = Ref<boolean>;

package/src/utils/content-renderer.ts

@@ -10,7 +10,7 @@
  *   - {{table:id}} / {{table:id, display}}  → nonVerbalRefResolver (table)
  *   - {{formula:id}} / {{formula:id, display}}  → nonVerbalRefResolver (formula)
  *   - {{cite:key[, render term]}}  → citeResolver
- *   - {{urn:...[, render term]}}  → urnRefResolver / xrefResolver
+ *   - {{urn:...[, render term]}}  → xrefResolver
  *   - {{concept_id[, render term]}}  → conceptRefResolver
  *   - {{designation[, render term]}}  → conceptRefResolver
  *
@@ -28,7 +28,6 @@ export type XrefResolver = (uri: string, term: string) => string;
 export type BibResolver = (refId: string, title: string) => string;
 export type CiteResolver = (key: string, label: string | null) => string;
 export type ConceptRefResolver = (conceptId: string, term: string) => string;
-export type UrnRefResolver = (uri: string, term: string) => string;
 export type NonVerbalRefResolver = (kind: NonVerbalKind, entityId: string, display?: string) => string;
 
 export interface RenderOptions {
@@ -36,7 +35,6 @@ export interface RenderOptions {
   bibResolver?: BibResolver;
   conceptRefResolver?: ConceptRefResolver;
   citeResolver?: CiteResolver;
-  urnRefResolver?: UrnRefResolver;
   nonVerbalRefResolver?: NonVerbalRefResolver;
 }
 
@@ -209,7 +207,6 @@ function resolveMentions(text: string, opts: RenderOptions): string {
       case 'urn-ref': {
         const uri = p.uri as string;
         const label = (p.label as string) ?? uri;
-        if (opts.urnRefResolver) return opts.urnRefResolver(uri, label);
         if (opts.xrefResolver) return opts.xrefResolver(uri, label);
         return escapeHtml(label);
       }