@glossarist/concept-browser 0.7.78 → 0.7.80

package/src/composables/use-concept-edges.ts

@@ -1,7 +1,20 @@
 import { computed, type ComputedRef } from 'vue';
 import type { Router } from 'vue-router';
-import type { Concept, PartitiveHyperedge as GlsPartitiveHyperedge, RelatedConcept } from 'glossarist';
-import type { Manifest, GraphEdge, PartitiveHyperedge } from '../adapters/types';
+import type {
+  Concept,
+  RelatedConcept,
+  PartitiveRelation as GlsPartitiveRelation,
+  PartitiveMember as GlsPartitiveMember,
+  TypeSharedPlurality as GlsTypeSharedPlurality,
+  ConceptRef,
+} from 'glossarist';
+import type {
+  Manifest,
+  GraphEdge,
+  PartitiveRelationWire,
+  PartitiveMemberWire,
+  TypeSharedPluralityWire,
+} from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
 import { UriRouter } from '../adapters/UriRouter';
@@ -114,63 +127,71 @@ export function useConceptEdges(
       });
     return [...direct, ...derived].filter(edge => {
       if (edge.type === 'broader_partitive' || edge.type === 'narrower_partitive') {
-        const heUris = conceptPartitiveHyperedges.value;
-        return !heUris.some(he => he.parts.includes(edge.ref as string) || he.comprehensive === edge.ref);
+        const refUri = resolveRefUri(edge.ref as { source: string | null; id: string | null } | null);
+        if (!refUri) return true;
+        const rels = conceptPartitiveRelations.value;
+        return !rels.some(rel =>
+          rel.comprehensive === refUri
+          || rel.partitives.some(m => m.uri === refUri),
+        );
       }
       return true;
     });
   });
 
-  const VALID_MARKERS = new Set(['double', 'dashed']);
-
-  function validateHyperedgeMarkers(markers: Iterable<string>): ('double' | 'dashed')[] {
-    const out: ('double' | 'dashed')[] = [];
-    for (const m of markers) {
-      if (!VALID_MARKERS.has(m)) {
-        throw new Error(`Invalid partitive hyperedge marker: "${m}". Allowed: double, dashed`);
-      }
-      out.push(m as 'double' | 'dashed');
-    }
-    return out;
-  }
-
-  function resolveLocalizedContent(content: unknown): string | undefined {
-    if (content == null) return undefined;
-    if (typeof content === 'string') return content;
-    if (typeof content === 'object' && content !== null) {
-      const obj = content as Record<string, string>;
-      return obj[registerId.value] ?? obj.default ?? obj.eng ?? Object.values(obj)[0];
-    }
-    return undefined;
-  }
-
-  // Concept-level partitive hyperedges (one-to-many decompositions).
-  // Each hyperedge is resolved to concrete target URIs for display.
-  // Independent of binary `conceptRelated` — see TODO.hyperedge/00.
-  const conceptPartitiveHyperedges = computed<PartitiveHyperedge[]>(() => {
+  // Concept-level partitive relations (ISO 704 one-to-many decompositions).
+  // Reads the glossarist-js native model (`concept.partitiveRelations`)
+  // and projects each relation into a URI-resolved wire shape for display.
+  // Independent of binary `conceptRelated`.
+  // v2 shape per concept-model/TODO.partitive-relation-v2.
+  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
     const source = conceptUriValue.value;
-    return (concept.value.partitiveHyperedges ?? [])
-      .map((he: GlsPartitiveHyperedge): PartitiveHyperedge | null => {
-        const comprehensive = resolveRefUri(he.comprehensive);
+    const relations: readonly GlsPartitiveRelation[] = concept.value.partitiveRelations;
+    return relations
+      .map((rel): PartitiveRelationWire | null => {
+        const comprehensive = resolveConceptRefUri(rel.comprehensive);
         if (!comprehensive) return null;
-        const parts = he.parts
-          .map(resolveRefUri)
-          .filter((u): u is string => !!u && u !== source);
-        if (parts.length === 0) return null;
+        const partitives: PartitiveMemberWire[] = rel.partitives
+          .map((m: GlsPartitiveMember): PartitiveMemberWire | null => {
+            const uri = resolveConceptRefUri(m.ref);
+            if (!uri || uri === source) return null;
+            return { uri, certainty: m.certainty };
+          })
+          .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
+        if (partitives.length === 0) return null;
+
         return {
           source,
           comprehensive,
-          parts,
-          enumeration: he.isOpen ? 'open' : 'closed',
-          markers: validateHyperedgeMarkers(he.markers),
-          label: resolveLocalizedContent(he.content),
+          partitives,
+          completeness: rel.completeness,
+          plurality: projectPlurality(rel.plurality),
+          criterion: rel.criterion ?? undefined,
           register: registerId.value,
         };
       })
-      .filter((he): he is PartitiveHyperedge => he !== null);
+      .filter((r: PartitiveRelationWire | null): r is PartitiveRelationWire => r !== null);
   });
 
-  function resolveRefUri(ref: { source?: string | null; id?: string | null } | null): string | null {
+  function projectPlurality(p: GlsTypeSharedPlurality | null): TypeSharedPluralityWire | null {
+    if (!p) return null;
+    const sharedTypeRef: ConceptRef | null = p.sharedType;
+    const sharedType = sharedTypeRef
+      ? [sharedTypeRef.source, sharedTypeRef.id].filter(Boolean).join(':') || null
+      : null;
+    return {
+      isShared: p.isShared,
+      isUncertain: p.isUncertain,
+      sharedType,
+    };
+  }
+
+  function resolveConceptRefUri(ref: ConceptRef | null): string | null {
+    if (!ref) return null;
+    return resolveRefUri({ source: ref.source ?? null, id: ref.id ?? null });
+  }
+
+  function resolveRefUri(ref: { source: string | null; id: string | null } | null): string | null {
     const target = resolveRelatedRef(ref);
     if (!target) return null;
     const m = store.manifests.get(target.registerId);
@@ -244,7 +265,7 @@ export function useConceptEdges(
     edgeBadgeColor,
     inverseEdgeType,
     conceptRelated,
-    conceptPartitiveHyperedges,
+    conceptPartitiveRelations,
     resolveRelatedRef,
     getResolvedRef,
     relatedLabel,

package/src/composables/use-dataset-stats.ts

@@ -0,0 +1,52 @@
+/**
+ * useDatasetStats — loads stats.json for a dataset register.
+ *
+ * Single source of truth for the DatasetStats wire shape; both
+ * DatasetView (summary badges) and StatsView (full table) consume it.
+ */
+import { ref, watch, type Ref } from 'vue';
+import type { DatasetStats } from '../adapters/dataset-stats';
+
+export function useDatasetStats(
+  registerId: Ref<string> | (() => string),
+  baseUrl: string = import.meta.env.BASE_URL,
+) {
+  const stats = ref<DatasetStats | null>(null);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
+
+  const resolved = typeof registerId === 'function' ? registerId() : registerId.value;
+
+  async function load(id: string) {
+    if (!id) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const resp = await fetch(`${baseUrl}data/${id}/stats.json`);
+      if (resp.ok) {
+        stats.value = await resp.json() as DatasetStats;
+      } else {
+        stats.value = null;
+      }
+    } catch (e: unknown) {
+      stats.value = null;
+      error.value = e instanceof Error ? e.message : String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  if (typeof registerId === 'function') {
+    // Re-fetch on app boot only; callers can call reload() to refresh.
+    load(resolved);
+  } else {
+    watch(registerId, id => load(id), { immediate: true });
+  }
+
+  function reload() {
+    const id = typeof registerId === 'function' ? registerId() : registerId.value;
+    load(id);
+  }
+
+  return { stats, loading, error, reload };
+}

package/src/config/page-types.ts

@@ -0,0 +1,67 @@
+/**
+ * Page type registry — OCP-compliant metadata for synthesized pages.
+ *
+ * Adding a new built-in page type = add one entry to PAGE_TYPES.
+ * `synthesizeGlobalPages` and `synthesizeDatasetPages` iterate the
+ * registry; no switches to edit.
+ *
+ * PageConfig.type stays a string — it tags the page's semantic kind
+ * for consumers (sidebar, future renderers). The router is the SSOT
+ * for route → view dispatch, not this registry.
+ *
+ * Mirrors the group-renderers.ts pattern: registry + lookup helper.
+ */
+
+export interface PageTypeDefinition {
+  readonly type: string;
+  readonly route: string;
+  readonly title: string;
+  readonly icon: string;
+  readonly scope: 'global' | 'dataset';
+  /** When defined, the page is only synthesized when features[flag] is truthy
+   *  (or, if the flag starts with '!', when features[flag.slice(1)] is falsy). */
+  readonly featureFlag?: string;
+  /** Synthesize automatically unless a declared page already uses this route. */
+  readonly autoSynthesize?: boolean;
+}
+
+export const PAGE_TYPES: readonly PageTypeDefinition[] = [
+  { type: 'home',       route: '',        title: 'Home',         icon: 'home',       scope: 'global',  autoSynthesize: true },
+  { type: 'concepts',   route: '',        title: 'Concepts',     icon: 'list',       scope: 'dataset', autoSynthesize: true },
+  { type: 'search',     route: 'search',  title: 'Search',       icon: 'search',     scope: 'global',  featureFlag: '!search',    autoSynthesize: true },
+  { type: 'graph',      route: 'graph',   title: 'Graph',        icon: 'graph',      scope: 'global',  featureFlag: '!graph',     autoSynthesize: true },
+  { type: 'ontology',   route: 'ontology',title: 'Ontology',     icon: 'schema',     scope: 'global',  featureFlag: '!ontology',  autoSynthesize: true },
+  { type: 'news',       route: 'news',    title: 'News',         icon: 'newspaper',  scope: 'global',  featureFlag: 'news', autoSynthesize: true },
+  { type: 'stats',      route: 'stats',   title: 'Statistics',   icon: 'chart',      scope: 'dataset', featureFlag: '!stats',     autoSynthesize: true },
+  { type: 'sources',    route: 'sources', title: 'Sources',      icon: 'database',   scope: 'dataset', autoSynthesize: true },
+  { type: 'about',      route: 'about',   title: 'About',        icon: 'info',       scope: 'dataset', featureFlag: '!about',     autoSynthesize: true },
+] as const;
+
+export type BuiltinPageType = typeof PAGE_TYPES[number]['type'];
+
+const PAGE_TYPE_INDEX: ReadonlyMap<string, PageTypeDefinition> = new Map(
+  PAGE_TYPES.map(p => [p.type, p]),
+);
+
+export function pageTypeOf(type: string): PageTypeDefinition | undefined {
+  return PAGE_TYPE_INDEX.get(type);
+}
+
+function featureEnabled(features: Record<string, unknown> | undefined, flag: string): boolean {
+  if (flag.startsWith('!')) {
+    return features?.[flag.slice(1)] !== false;
+  }
+  return Boolean(features?.[flag]);
+}
+
+/** Synthesize the auto-on pages for a given scope, respecting feature flags
+ *  and skipping routes already declared by the user. */
+export function synthesizePages(
+  scope: 'global' | 'dataset',
+  features: Record<string, unknown> | undefined,
+  declaredRoutes: ReadonlySet<string>,
+): PageTypeDefinition[] {
+  return PAGE_TYPES.filter(p => p.scope === scope && p.autoSynthesize)
+    .filter(p => !p.featureFlag || featureEnabled(features, p.featureFlag))
+    .filter(p => !declaredRoutes.has(p.route));
+}

package/src/config/types.ts

@@ -137,7 +137,12 @@ export const FORMAT_LABELS: Record<string, string> = {
 
 // === Pages ===
 
-export type PageType = 'page' | 'news' | 'contributors' | 'about' | 'stats' | 'custom';
+/**
+ * Page type tag. Any string is allowed — built-in tags are listed in
+ * `page-types.ts` PAGE_TYPES registry. Adding a new built-in type is
+ * a registry entry, not an edit to this union.
+ */
+export type PageType = string;
 
 export interface PageConfig {
   type: PageType;

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

@@ -1,6 +1,7 @@
 import { ref, computed } from 'vue';
 import type { PageConfig, SiteColors } from './types';
 import type { DatasetGroup } from './types';
+import { synthesizePages } from './page-types';
 import { locale } from '../i18n';
 
 export interface RuntimeSiteConfig {
@@ -128,43 +129,26 @@ function synthesizeGlobalPages(features?: Record<string, unknown>, pages?: PageC
   const declared = pages?.filter(p => !p.datasetScoped) ?? [];
   const declaredRoutes = new Set(declared.map(p => p.route));
 
-  const result: PageConfig[] = [
-    { type: 'custom', route: '', title: 'Home', icon: 'home' },
-  ];
-  if (features?.search !== false && !declaredRoutes.has('search')) {
-    result.push({ type: 'custom', route: 'search', title: 'Search', icon: 'search' });
-  }
-  if (features?.graph !== false && !declaredRoutes.has('graph')) {
-    result.push({ type: 'custom', route: 'graph', title: 'Graph', icon: 'graph' });
-  }
-  if (features?.ontology !== false && !declaredRoutes.has('ontology')) {
-    result.push({ type: 'custom', route: 'ontology', title: 'Ontology', icon: 'schema' });
-  }
-  if (features?.news && !declaredRoutes.has('news')) {
-    result.push({ type: 'news', route: 'news', title: 'News', icon: 'newspaper' });
-  }
+  const synthesized = synthesizePages('global', features, declaredRoutes)
+    .map(p => ({ type: p.type, route: p.route, title: p.title, icon: p.icon }));
 
-  return [...result, ...declared];
+  return [...synthesized, ...declared];
 }
 
 function synthesizeDatasetPages(features?: Record<string, unknown>, pages?: PageConfig[]): PageConfig[] {
   const declared = pages?.filter(p => p.datasetScoped) ?? [];
   const declaredRoutes = new Set(declared.map(p => p.route));
 
-  const result: PageConfig[] = [
-    { type: 'custom', route: '', title: 'Concepts', icon: 'list', datasetScoped: true },
-  ];
-  if (features?.stats !== false && !declaredRoutes.has('stats')) {
-    result.push({ type: 'stats', route: 'stats', title: 'Statistics', icon: 'chart', datasetScoped: true });
-  }
-  if (!declaredRoutes.has('sources')) {
-    result.push({ type: 'sources', route: 'sources', title: 'Sources', icon: 'database', datasetScoped: true });
-  }
-  if (features?.about !== false && !declaredRoutes.has('about')) {
-    result.push({ type: 'about', route: 'about', title: 'About', icon: 'info', datasetScoped: true });
-  }
+  const synthesized = synthesizePages('dataset', features, declaredRoutes)
+    .map(p => ({
+      type: p.type,
+      route: p.route,
+      title: p.title,
+      icon: p.icon,
+      datasetScoped: true as const,
+    }));
 
-  return [...result, ...declared];
+  return [...synthesized, ...declared];
 }
 
 export function useSiteConfig() {

package/src/data/taxonomies.json

@@ -45,6 +45,12 @@
         "iri": "gloss:status/retired",
         "prefLabel": "retired",
         "definition": "The concept has been retired from active use."
+      },
+      "external": {
+        "id": "external",
+        "iri": "gloss:status/external",
+        "prefLabel": "external",
+        "definition": "An external concept: referenced but not defined here. May be resolved later when another dataset is loaded (concept-model TODO.partitive-relation-v2 item 06)."
       }
     },
     "colors": {
@@ -54,7 +60,8 @@
       "not_valid": "bg-red-50 text-red-700",
       "invalid": "bg-red-50 text-red-700",
       "superseded": "bg-red-50 text-red-700",
-      "retired": "badge-gray"
+      "retired": "badge-gray",
+      "external": "bg-purple-50 text-purple-700"
     }
   },
   "entryStatus": {
@@ -264,6 +271,22 @@
         "category": "lifecycle",
         "inverseOf": "supersedes"
       },
+      "provides": {
+        "id": "provides",
+        "iri": "gloss:rel/provides",
+        "prefLabel": "provides",
+        "definition": "This concept provides substance for an external concept (one we reference but don't define). Direction: subject → external. Per concept-model TODO.partitive-relation-v2 item 07.",
+        "category": "lifecycle",
+        "inverseOf": "provided_by"
+      },
+      "provided_by": {
+        "id": "provided_by",
+        "iri": "gloss:rel/provided_by",
+        "prefLabel": "provided by",
+        "definition": "This external concept is provided by (fulfilled by) the object concept. Inverse of provides.",
+        "category": "lifecycle",
+        "inverseOf": "provides"
+      },
       "compare": {
         "id": "compare",
         "iri": "gloss:rel/compare",

package/src/i18n/locales/eng.yml

@@ -58,6 +58,12 @@ concept.example: Example
 concept.sources: Sources
 concept.designations: Designations
 concept.relations: Relations
+concept.compareWith: Compare with this edition
+concept.compareEditions: Compare editions
+concept.partitiveRelations: Partitive relations
+partitive.relations: Partitive relations
+partitive.plurality.shared: shared type
+partitive.plurality.uncertain: uncertain
 concept.classification: Classification
 concept.domains: Domains
 concept.tags: Tags

package/src/utils/partitive-relation-styling.ts

@@ -0,0 +1,62 @@
+/**
+ * Partitive relation styling — colors for one-to-many decompositions.
+ *
+ * Independent of relationship-categories.ts (which handles binary edges).
+ * Partitive relations have their own visual language:
+ *   - completeness (complete/partial) affects opacity
+ *   - plurality (type-shared, uncertain) adds accent badges
+ *
+ * v2 redesign: replaces v1 hyperedge-styling.ts per
+ * concept-model/TODO.partitive-relation-v2.
+ */
+
+import type { TypeSharedPluralityWire } from '../adapters/types';
+
+const BASE_LIGHT = '#0d9488';
+const BASE_DARK = '#2dd4bf';
+const ACCENT_SHARED_LIGHT = '#3b82f6';
+const ACCENT_SHARED_DARK = '#60a5fa';
+const ACCENT_UNCERTAIN_LIGHT = '#f59e0b';
+const ACCENT_UNCERTAIN_DARK = '#fbbf24';
+
+export interface PartitiveRelationStyle {
+  color: string;
+  badgeClass: string;
+  opacity: number;
+}
+
+export function partitiveRelationStyle(
+  completeness: 'complete' | 'partial',
+  plurality: TypeSharedPluralityWire | null,
+  isDark: boolean,
+): PartitiveRelationStyle {
+  const base = isDark ? BASE_DARK : BASE_LIGHT;
+  const opacity = completeness === 'partial' ? 0.6 : 1.0;
+
+  let badgeClass = 'badge-teal';
+  if (plurality?.isShared) {
+    badgeClass = 'badge-blue';
+    if (plurality.isUncertain) {
+      badgeClass = 'badge-yellow';
+    }
+  }
+
+  return { color: base, badgeClass, opacity };
+}
+
+export function pluralityColor(
+  plurality: TypeSharedPluralityWire,
+  isDark: boolean,
+): string {
+  if (plurality.isUncertain) return isDark ? ACCENT_UNCERTAIN_DARK : ACCENT_UNCERTAIN_LIGHT;
+  if (plurality.isShared) return isDark ? ACCENT_SHARED_DARK : ACCENT_SHARED_LIGHT;
+  return isDark ? BASE_DARK : BASE_LIGHT;
+}
+
+export function completenessLabel(completeness: 'complete' | 'partial'): string {
+  return completeness === 'partial' ? 'Partial' : 'Complete';
+}
+
+export function certaintyLabel(certainty: 'confirmed' | 'possible'): string {
+  return certainty === 'possible' ? 'Possible' : 'Confirmed';
+}

package/src/views/DatasetView.vue

@@ -5,6 +5,7 @@ import { useVocabularyStore } from '../stores/vocabulary';
 import { useUiStore } from '../stores/ui';
 import { useDsStyle } from '../utils/dataset-style';
 import { useDatasetLoader } from '../composables/use-dataset-loader';
+import { useDatasetStats } from '../composables/use-dataset-stats';
 import { FORMAT_LABELS } from '../config/types';
 import { langName, langLabel, sortLanguages } from '../utils/lang';
 import ConceptCard from '../components/ConceptCard.vue';
@@ -21,6 +22,7 @@ const store = useVocabularyStore();
 const uiStore = useUiStore();
 const { getStyle } = useDsStyle();
 const { ensureLoaded, loading, localError } = useDatasetLoader(() => props.registerId);
+const { stats: datasetStats } = useDatasetStats(() => props.registerId);
 const { t } = useI18n();
 const { localizedDatasetField } = useSiteConfig();
 const route = useRoute();
@@ -331,10 +333,10 @@ function clearSection() {
         <router-link :to="{ name: 'about', params: { registerId } }" class="badge badge-purple hover:opacity-80 transition-opacity">
           {{ t('nav.about') }}
         </router-link>
-        <router-link v-if="manifest.sourceCount" :to="{ name: 'sources', params: { registerId } }" class="badge badge-gray hover:opacity-80 transition-opacity">
-          {{ manifest.sourceCount }} {{ t('dataset.sources') }}
+        <router-link v-if="datasetStats?.sourceCount" :to="{ name: 'sources', params: { registerId } }" class="badge badge-gray hover:opacity-80 transition-opacity">
+          {{ datasetStats.sourceCount }} {{ t('dataset.sources') }}
         </router-link>
-        <span v-if="manifest.relationshipCount" class="badge badge-yellow">{{ manifest.relationshipCount.toLocaleString() }} {{ t('dataset.relationships') }}</span>
+        <span v-if="datasetStats?.relationshipCount" class="badge badge-yellow">{{ datasetStats.relationshipCount.toLocaleString() }} {{ t('dataset.relationships') }}</span>
       </div>
     </div>
 

package/src/views/StatsView.vue

@@ -1,8 +1,9 @@
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue';
+import { computed } from 'vue';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
 import { useDatasetLoader } from '../composables/use-dataset-loader';
+import { useDatasetStats } from '../composables/use-dataset-stats';
 import { langName, langLabel } from '../utils/lang';
 import { useI18n } from '../i18n';
 
@@ -11,6 +12,7 @@ const props = defineProps<{ registerId?: string }>();
 const store = useVocabularyStore();
 const { getColor } = useDsStyle();
 const { loading, localError, ensureLoaded, resolvedId } = useDatasetLoader(() => props.registerId);
+const { stats: statsData, reload: reloadStats } = useDatasetStats(resolvedId);
 const { t } = useI18n();
 
 const manifest = computed(() => store.manifests.get(resolvedId.value));
@@ -54,26 +56,6 @@ function coverageColor(ratio: number): string {
   return 'bg-red-400';
 }
 
-interface StatsData {
-  sourceCount: number;
-  sources: Array<{ ref: string; types: string[]; conceptCount: number }>;
-  relationshipCount: number;
-  relationshipTypes: Record<string, number>;
-}
-
-const statsData = ref<StatsData | null>(null);
-
-async function loadStats() {
-  if (!resolvedId.value) return;
-  const base = import.meta.env.BASE_URL;
-  try {
-    const resp = await fetch(`${base}data/${resolvedId.value}/stats.json`);
-    if (resp.ok) statsData.value = await resp.json();
-  } catch {}
-}
-
-watch(() => resolvedId.value, () => { loadStats(); }, { immediate: true });
-
 const relEntries = computed(() => {
   if (!statsData.value?.relationshipTypes) return [];
   return Object.entries(statsData.value.relationshipTypes)
@@ -92,6 +74,11 @@ function sourceTypeBadge(type: string): string {
   if (type === 'lineage') return 'badge-yellow';
   return 'badge-gray';
 }
+
+async function reloadAll() {
+  await ensureLoaded();
+  reloadStats();
+}
 </script>
 
 <template>
@@ -115,7 +102,7 @@ function sourceTypeBadge(type: string): string {
       <div class="card p-8 border-red-200 bg-red-50/50 text-center">
         <p class="text-red-700 font-medium mb-1">{{ t('stats.failedToLoad') }}</p>
         <p class="text-sm text-red-600/80 mb-4">{{ localError }}</p>
-        <button @click="ensureLoaded" class="btn-primary">{{ t('stats.retry') }}</button>
+        <button @click="reloadAll" class="btn-primary">{{ t('stats.retry') }}</button>
       </div>
     </template>
     <template v-else-if="manifest">

package/src/__tests__/hyperedge-styling.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { hyperedgeStyle, markerColor, enumerationLabel } from '../utils/hyperedge-styling';
-
-describe('hyperedge-styling', () => {
-  describe('hyperedgeStyle', () => {
-    it('returns full opacity for closed enumeration', () => {
-      expect(hyperedgeStyle('closed', [], false).opacity).toBe(1.0);
-    });
-
-    it('returns reduced opacity for open enumeration', () => {
-      expect(hyperedgeStyle('open', [], false).opacity).toBe(0.6);
-    });
-
-    it('uses teal badge class for closed with no markers', () => {
-      expect(hyperedgeStyle('closed', [], false).badgeClass).toBe('badge-teal');
-    });
-
-    it('uses blue badge class for double marker', () => {
-      expect(hyperedgeStyle('closed', ['double'], false).badgeClass).toBe('badge-blue');
-    });
-
-    it('uses yellow badge class for dashed marker', () => {
-      expect(hyperedgeStyle('closed', ['dashed'], false).badgeClass).toBe('badge-yellow');
-    });
-
-    it('returns different colors in dark mode', () => {
-      const light = hyperedgeStyle('closed', [], false);
-      const dark = hyperedgeStyle('closed', [], true);
-      expect(light.color).not.toBe(dark.color);
-    });
-  });
-
-  describe('markerColor', () => {
-    it('returns blue for double marker', () => {
-      expect(markerColor('double', false)).toBe('#3b82f6');
-    });
-
-    it('returns amber for dashed marker', () => {
-      expect(markerColor('dashed', false)).toBe('#f59e0b');
-    });
-
-    it('returns dark-mode variants', () => {
-      expect(markerColor('double', true)).toBe('#60a5fa');
-      expect(markerColor('dashed', true)).toBe('#fbbf24');
-    });
-  });
-
-  describe('enumerationLabel', () => {
-    it('labels closed as "Closed (complete)"', () => {
-      expect(enumerationLabel('closed')).toBe('Closed (complete)');
-    });
-
-    it('labels open as "Open (partial)"', () => {
-      expect(enumerationLabel('open')).toBe('Open (partial)');
-    });
-  });
-});