@glossarist/concept-browser 0.7.103 → 0.7.105

package/package.json

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

package/src/__tests__/components/rake-bundles.test.ts

@@ -315,4 +315,24 @@ describe('drawRakeBundles — rake contract', () => {
     expect(svg.querySelectorAll('circle.rake-junction').length).toBe(2);
     expect(svg.querySelectorAll('path').length).toBe(2);
   });
+
+  it('renders ellipsis "…" text when completeness is partial', () => {
+    const svg = makeSvg();
+    drawRakeBundles(svg, pos, {
+      isDark: false, color: '#0d9488', isMuted: false,
+      relations: [makeRelation({ completeness: 'partial' })],
+    });
+    const ellipsis = svg.querySelectorAll('text.rake-ellipsis');
+    expect(ellipsis.length).toBe(1);
+    expect(ellipsis[0].textContent).toBe('…');
+  });
+
+  it('does NOT render ellipsis when completeness is complete', () => {
+    const svg = makeSvg();
+    drawRakeBundles(svg, pos, {
+      isDark: false, color: '#0d9488', isMuted: false,
+      relations: [makeRelation({ completeness: 'complete' })],
+    });
+    expect(svg.querySelectorAll('text.rake-ellipsis').length).toBe(0);
+  });
 });

package/src/__tests__/utils/external-detection.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isExternalConcept,
+  hasProvidedBy,
+  isDanglingExternal,
+  formatExternalLabel,
+  type ConceptStoreLike,
+} from '../../utils/external-detection';
+
+const mockStore: ConceptStoreLike = {
+  lookup(ref) {
+    if (ref?.id === 'ext-1') {
+      return { status: 'external', relatedConcepts: [{ type: 'provided_by' }] };
+    }
+    if (ref?.id === 'ext-2') {
+      return { status: 'external', relatedConcepts: [] };
+    }
+    if (ref?.id === 'int-1') {
+      return { status: 'valid', relatedConcepts: [] };
+    }
+    return null;
+  },
+};
+
+describe('external-detection', () => {
+  describe('isExternalConcept', () => {
+    it('returns true when the concept status is external', () => {
+      expect(isExternalConcept({ source: 's', id: 'ext-1' }, mockStore)).toBe(true);
+    });
+
+    it('returns false when the concept status is valid', () => {
+      expect(isExternalConcept({ source: 's', id: 'int-1' }, mockStore)).toBe(false);
+    });
+
+    it('returns false when the concept is not found', () => {
+      expect(isExternalConcept({ source: 's', id: 'unknown' }, mockStore)).toBe(false);
+    });
+
+    it('returns false when ref is null', () => {
+      expect(isExternalConcept(null, mockStore)).toBe(false);
+    });
+
+    it('returns false when store is null', () => {
+      expect(isExternalConcept({ source: 's', id: 'ext-1' }, null)).toBe(false);
+    });
+  });
+
+  describe('hasProvidedBy', () => {
+    it('returns true when the external concept has a provided_by edge', () => {
+      expect(hasProvidedBy({ source: 's', id: 'ext-1' }, mockStore)).toBe(true);
+    });
+
+    it('returns false when the external concept has no provided_by edge', () => {
+      expect(hasProvidedBy({ source: 's', id: 'ext-2' }, mockStore)).toBe(false);
+    });
+
+    it('returns false when the concept is not found', () => {
+      expect(hasProvidedBy({ source: 's', id: 'unknown' }, mockStore)).toBe(false);
+    });
+  });
+
+  describe('isDanglingExternal', () => {
+    it('returns false when the external concept has provided_by (resolved)', () => {
+      expect(isDanglingExternal({ source: 's', id: 'ext-1' }, mockStore)).toBe(false);
+    });
+
+    it('returns true when the external concept has no provided_by (dangling)', () => {
+      expect(isDanglingExternal({ source: 's', id: 'ext-2' }, mockStore)).toBe(true);
+    });
+
+    it('returns false for internal concepts', () => {
+      expect(isDanglingExternal({ source: 's', id: 'int-1' }, mockStore)).toBe(false);
+    });
+  });
+
+  describe('formatExternalLabel', () => {
+    it('wraps the label in parentheses for external concepts', () => {
+      expect(formatExternalLabel('precision condition', true)).toBe('(precision condition)');
+    });
+
+    it('returns the label as-is for internal concepts', () => {
+      expect(formatExternalLabel('measurement unit', false)).toBe('measurement unit');
+    });
+  });
+});

package/src/components/PartitiveRelationDiagram.vue

@@ -259,6 +259,18 @@ function tooltipFor(member: PartitiveMemberLabeled): string | undefined {
       v-bind="frameStrokeAttrs"
     />
 
+    <!-- Ellipsis marker for partial completeness (ISO 704:2022) -->
+    <text
+      v-if="completeness === 'partial'"
+      :x="layout.spineEndX + 6" :y="layout.spineY + 4"
+      class="ellipsis-marker"
+      fill="currentColor"
+      font-size="12"
+      font-family="JetBrains Mono, monospace"
+      font-weight="600"
+      opacity="0.7"
+    >…</text>
+
     <!-- Drops + partitive nodes -->
     <g v-for="(slot, i) in layout.partitiveSlots" :key="i">
       <!-- Primary drop line -->

package/src/components/relation-sphere/rake-bundles.ts

@@ -140,6 +140,23 @@ export function drawRakeBundles(
       drawSegment(svg, opts.color, spineStartX, spineStartY, spineEndX, spineEndY, { width: FRAME_STROKE_WIDTH });
     }
 
+    // 6b. Ellipsis marker for partial completeness — ISO 704:2022
+    //     "..." at the open end of the spine indicates further members
+    //     exist but are not encoded.
+    if (rel.completeness === 'partial') {
+      const ellipsis = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+      ellipsis.setAttribute('class', 'rake-ellipsis');
+      ellipsis.setAttribute('x', String(spineEndX + spineDirX * 4));
+      ellipsis.setAttribute('y', String(spineEndY + spineDirY * 4 + 3));
+      ellipsis.setAttribute('fill', opts.color);
+      ellipsis.setAttribute('font-size', '10');
+      ellipsis.setAttribute('font-family', 'JetBrains Mono, monospace');
+      ellipsis.setAttribute('font-weight', '600');
+      ellipsis.setAttribute('opacity', '0.8');
+      ellipsis.textContent = '…';
+      svg.appendChild(ellipsis);
+    }
+
     // 7. Drops: tooth → partitive (per-member multiplicity + delimiting).
     //    1 or 2 parallel lines per the style.
     for (const tooth of teeth) {

package/src/layouts/Default.astro

@@ -68,12 +68,7 @@ const fontBody = brandingFonts?.body?.family
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link rel="preload" as="style" href={fontsUrl} onload="this.rel='stylesheet'">
     <noscript><link href={fontsUrl} rel="stylesheet"></noscript>
-    <style is:global>
-      :root {
-        --font-header: ${fontHeader};
-        --font-body: ${fontBody};
-      }
-    </style>
+    <Fragment set:html={`<style>:root{--font-header:${fontHeader};--font-body:${fontBody}}</style>`} />
     <script is:inline>
       (function() {
         const c = document.cookie.split(';').map(s => s.trim()).find(s => s.startsWith('theme='));

package/src/utils/external-detection.ts

@@ -0,0 +1,74 @@
+/**
+ * External concept detection — ISO 704:2022 external concepts.
+ *
+ * An "external concept" is one referenced from this dataset but defined
+ * elsewhere (status: 'external'). In diagrams, external concepts are
+ * shown in parentheses with a dashed border per ISO 704:2022 §5.5.4.3.1.
+ *
+ * Detection requires concept resolution (looking up the referenced
+ * concept's status), which is a consumer concern — the model itself
+ * stays pure. These utility functions take a conceptStore/lookup
+ * callback provided by the caller.
+ */
+
+export interface ConceptLike {
+  status?: string | null;
+  relatedConcepts?: ReadonlyArray<{ type?: string | null }>;
+}
+
+export interface ConceptStoreLike {
+  lookup(ref: { source?: string | null; id?: string | null }): ConceptLike | null;
+}
+
+export interface RefLike {
+  source?: string | null;
+  id?: string | null;
+}
+
+/**
+ * Check if a member's concept resolves to status: external.
+ */
+export function isExternalConcept(
+  ref: RefLike | null | undefined,
+  store: ConceptStoreLike | null | undefined,
+): boolean {
+  if (!ref || !store) return false;
+  const concept = store.lookup(ref);
+  return concept?.status === 'external';
+}
+
+/**
+ * Check if an external concept has a provided_by edge for resolution.
+ * Without provided_by, the reference dangles — the decomposition is
+ * incomplete.
+ */
+export function hasProvidedBy(
+  ref: RefLike | null | undefined,
+  store: ConceptStoreLike | null | undefined,
+): boolean {
+  if (!ref || !store) return false;
+  const concept = store.lookup(ref);
+  if (!concept?.relatedConcepts) return false;
+  return concept.relatedConcepts.some(rc => rc.type === 'provided_by');
+}
+
+/**
+ * Check if an external concept's reference dangles (no provided_by edge).
+ */
+export function isDanglingExternal(
+  ref: RefLike | null | undefined,
+  store: ConceptStoreLike | null | undefined,
+): boolean {
+  return isExternalConcept(ref, store) && !hasProvidedBy(ref, store);
+}
+
+/**
+ * Format a label for an external concept — parenthetical per ISO 704.
+ * Returns `"(label)"` for external concepts, `label` for internal.
+ */
+export function formatExternalLabel(
+  label: string,
+  isExternal: boolean,
+): string {
+  return isExternal ? `(${label})` : label;
+}