@glossarist/concept-browser 0.7.101 → 0.7.103

package/src/adapters/model-bridge/bridges.ts

@@ -1,159 +0,0 @@
-/**
- * WeakMap bridges for fields not yet in glossarist-js's published d.ts.
- *
- * Each bridge attaches data the model doesn't expose via typed
- * properties. Getters retrieve it; attachBridges() populates it after
- * Concept.fromJSON creates the model instances.
- *
- * Remove each bridge when glossarist-js publishes native support
- * (tracked by PR glossarist/glossarist-js#31 and BRIDGES.md).
- */
-import {
-  Concept,
-  LocalizedConcept,
-  ConceptRef,
-  Citation,
-  DetailedDefinition,
-} from 'glossarist';
-
-// Annotations: LocalizedConcept.annotations
-const extraAnnotations = new WeakMap<LocalizedConcept, DetailedDefinition[]>();
-
-export function getAnnotations(lc: LocalizedConcept): DetailedDefinition[] {
-  return extraAnnotations.get(lc) ?? [];
-}
-
-// Designation relationship targets: RelatedConcept.target (string)
-const designationTargets = new WeakMap<object, string>();
-
-export function getDesignationTarget(rc: { type?: string | null; content?: string | null; target?: string | null; ref?: any }): string | null {
-  return designationTargets.get(rc) ?? rc.target ?? null;
-}
-
-// ConceptRef text: human-readable label alongside source/id
-const refTexts = new WeakMap<ConceptRef, string>();
-
-export function getRefText(ref: ConceptRef): string | null {
-  return refTexts.get(ref) ?? null;
-}
-
-// RelatedConcept.sourceId: links a citation reference back to its source entry
-const relatedSourceIds = new WeakMap<object, string>();
-
-export function getRelatedSourceId(rc: object): string | null {
-  return relatedSourceIds.get(rc) ?? null;
-}
-
-// RelatedConcept.citation: embedded citation data for cite-ref references
-const relatedCitations = new WeakMap<object, Record<string, unknown>>();
-
-export function getRelatedCitation(rc: object): Record<string, unknown> | null {
-  return relatedCitations.get(rc) ?? null;
-}
-
-// Relationship types whose target is a designation string, not a concept ref.
-export const DESIGNATION_REL_TYPES = new Set(['abbreviated_form_for', 'short_form_for']);
-
-export function attachSourcedFromToSources(
-  sources: readonly { sourced_from?: unknown }[],
-  rawSources: unknown,
-): void {
-  if (!Array.isArray(rawSources)) return;
-  for (let i = 0; i < sources.length && i < rawSources.length; i++) {
-    const raw = rawSources[i] as Record<string, unknown> | undefined;
-    if (raw?.sourced_from && Array.isArray(raw.sourced_from)) {
-      (sources[i] as { sourced_from: unknown }).sourced_from = raw.sourced_from.map(
-        (sf: unknown) => sf instanceof Citation ? sf : Citation.fromJSON(sf as Record<string, unknown>)
-      );
-    }
-  }
-}
-
-/**
- * Attach bridged fields (ref text, sourceId, citation) to RelatedConcept instances
- * from the raw deserialized data. Called after Concept.fromJSON creates the model
- * instances, since RelatedConcept.fromJSON only reads type/content/ref.
- */
-function attachRelatedBridges(
-  modelRelated: Array<{ type?: string | null; content?: Record<string, string> | string | null; ref?: any; related?: any[] }>,
-  rawRelated: unknown[],
-): void {
-  for (const rawRel of rawRelated) {
-    if (!rawRel || typeof rawRel !== 'object') continue;
-    const rel = rawRel as Record<string, unknown>;
-    const relType = rel.type as string | undefined;
-    const rc = relType ? modelRelated.find(r => r.type === relType) : undefined;
-    if (!rc) continue;
-
-    // Ref text
-    if (rc.ref) {
-      const rawRef = rel.ref as Record<string, unknown> | undefined;
-      if (rawRef?.text && typeof rawRef.text === 'string') {
-        refTexts.set(rc.ref, rawRef.text);
-      }
-    }
-
-    // Designation target
-    if (rel.target && typeof rel.target === 'string') {
-      designationTargets.set(rc, rel.target);
-    }
-
-    // Source ID — links citation reference back to the ConceptSource entry
-    if (rel.sourceId && typeof rel.sourceId === 'string') {
-      relatedSourceIds.set(rc, rel.sourceId);
-    }
-
-    // Citation — embedded origin data for cite-ref references
-    if (rel.citation && typeof rel.citation === 'object') {
-      relatedCitations.set(rc, rel.citation as Record<string, unknown>);
-    }
-  }
-}
-
-export function attachBridges(concept: Concept, localizations: Record<string, unknown>): void {
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    const raw = localizations[lang];
-    if (!lc || !raw || typeof raw !== 'object') continue;
-    const rawObj = raw as Record<string, unknown>;
-
-    // Attach sourced_from to localization-level sources
-    attachSourcedFromToSources(lc.sources as unknown as { sourced_from?: unknown }[], rawObj.sources);
-
-    // Annotations
-    const annList = rawObj.annotations;
-    if (Array.isArray(annList) && annList.length > 0) {
-      extraAnnotations.set(lc, annList.map((a: Record<string, unknown>) =>
-        DetailedDefinition.fromJSON({ content: (a.content as string) ?? '' }) as DetailedDefinition,
-      ));
-    }
-
-    // Designation-level relationship targets, ref text, sourceId, citation
-    const rawTerms = rawObj.terms;
-    if (Array.isArray(rawTerms)) {
-      for (let ti = 0; ti < rawTerms.length; ti++) {
-        const rawTerm = rawTerms[ti];
-        if (!rawTerm || typeof rawTerm !== 'object') continue;
-        const rawT = rawTerm as Record<string, unknown>;
-        const rawDesignation = rawT.designation as string | undefined;
-        if (!rawDesignation) continue;
-        const designation = lc.terms.find(d => d.designation === rawDesignation);
-        if (!designation) continue;
-        const rawRelated = rawT.related;
-        if (!Array.isArray(rawRelated)) continue;
-        attachRelatedBridges(designation.related, rawRelated);
-        // Attach sourced_from to designation-level sources
-        attachSourcedFromToSources(
-          designation.sources as unknown as { sourced_from?: unknown }[],
-          rawT.sources,
-        );
-      }
-    }
-
-    // Localization-level related concepts
-    const rawRelated = rawObj.related;
-    if (Array.isArray(rawRelated)) {
-      attachRelatedBridges(lc.related, rawRelated);
-    }
-  }
-}

package/src/adapters/model-bridge/concept.ts

@@ -1,97 +0,0 @@
-/**
- * Top-level Concept loading: JSON-LD detection, Concept.fromJSON
- * orchestration, summary projection, URI construction.
- *
- * This module is the orchestration layer — mappers, bridges, and
- * partitive mapping live in their respective sibling modules.
- */
-import { Concept } from 'glossarist';
-import type { ConceptSummary } from '../types';
-import { ConceptIdentity } from '../concept-identity';
-import { GL } from '../wire-keys';
-import { isJsonLd, mapLocalizedFromJsonLd, mapRelatedFromJsonLd } from './mappers';
-import { mapHyperedgeFromJsonLd } from './hyperedge';
-import { normalizeEntityRefs } from './entity-refs';
-import { attachBridges, attachSourcedFromToSources } from './bridges';
-import type { JsonLdConcept } from './jsonld-types';
-
-function conceptFromJsonLd(doc: JsonLdConcept): Concept {
-  const id = String(doc[GL.IDENTIFIER] ?? doc['@id']?.split('/').pop() ?? '');
-  const localizations: Record<string, unknown> = {};
-
-  const rawLc = doc[GL.LOCALIZED_CONCEPT] ?? {};
-  for (const [lang, lc] of Object.entries(rawLc)) {
-    if (lc && typeof lc === 'object') {
-      localizations[lang] = mapLocalizedFromJsonLd(lc);
-    }
-  }
-
-  const related = (doc[GL.RELATED] ?? []).map(mapRelatedFromJsonLd);
-
-  // Unified hyperedge mapping: both partitive and generic relations
-  // share the same JSON-LD wire shape. glossarist-js dispatches by
-  // wire key (`partitive_relations` / `generic_relations`).
-  const partitiveRelations = (doc[GL.PARTITIVE_RELATIONS] ?? [])
-    .map((r: any) => mapHyperedgeFromJsonLd(r, 'gl:hasPartitive'))
-    .filter((r): r is Record<string, unknown> => r !== null);
-
-  const genericRelations = (doc[GL.GENERIC_RELATIONS] ?? [])
-    .map((r: any) => mapHyperedgeFromJsonLd(r, 'gl:hasGeneric'))
-    .filter((r): r is Record<string, unknown> => r !== null);
-
-  const tagsArr = doc[GL.TAGS];
-  const tags = Array.isArray(tagsArr) ? [...tagsArr] : [];
-
-  const concept = Concept.fromJSON({
-    id,
-    term: doc[GL.TERM] ?? null,
-    uri: doc['@id'] ?? null,
-    localizations,
-    related,
-    partitive_relations: partitiveRelations,
-    generic_relations: genericRelations,
-    tags,
-    figures: normalizeEntityRefs(doc[GL.FIGURE_REF]),
-    tables: normalizeEntityRefs(doc[GL.TABLE_REF]),
-    formulas: normalizeEntityRefs(doc[GL.FORMULA_REF]),
-    status: null,
-  });
-
-  attachBridges(concept, localizations);
-  return concept;
-}
-
-export function conceptFromJson(doc: Record<string, unknown>): Concept {
-  if (isJsonLd(doc)) {
-    return conceptFromJsonLd(doc as JsonLdConcept);
-  }
-  const concept = Concept.fromJSON(doc);
-  const locs = (doc as Record<string, unknown>).localizations as Record<string, unknown> | undefined;
-  if (locs) attachBridges(concept, locs);
-  attachSourcedFromToSources(
-    concept.sources as unknown as { sourced_from?: unknown }[],
-    (doc as Record<string, unknown>).sources,
-  );
-  return concept;
-}
-
-export function conceptToSummary(concept: Concept): ConceptSummary {
-  const designations: Record<string, string> = {};
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    if (lc?.primaryDesignation) {
-      designations[lang] = lc.primaryDesignation;
-    }
-  }
-  return {
-    id: concept.id,
-    designations,
-    eng: designations.eng || Object.values(designations)[0] || '',
-    status: concept.status ?? 'valid',
-  };
-}
-
-export function conceptUri(concept: Concept, registerId: string, uriBase: string): string {
-  if (concept.uri) return concept.uri;
-  return new ConceptIdentity(concept.id, registerId, uriBase).uri;
-}

package/src/adapters/model-bridge/entity-refs.ts

@@ -1,49 +0,0 @@
-/**
- * Non-verbal entity reference normalization.
- *
- * Normalizes JSON-LD structural entity refs (`gl:figureRef` /
- * `gl:tableRef` / `gl:formulaRef`) into the shape
- * `NonVerbalReference.fromJSON` expects.
- *
- * Accepts three wire forms:
- *   - bare string ID
- *   - `{ "@id": "../kind/foo" }`
- *   - `{ "@id": "../kind/foo", "gl:display": "Figure 3" }`
- *
- * Emits the canonical `{ ref, display? }` shape. The path's last
- * segment is the entity id; the field name (`figureRef` vs `tableRef`
- * vs `formulaRef`) is the kind discriminator upstream.
- */
-import { GL } from '../wire-keys';
-
-export function normalizeEntityRefs(raw: unknown): unknown[] {
-  if (!Array.isArray(raw)) return [];
-  return raw.map(normalizeOneEntityRef).filter((v): v is Record<string, string> => v !== null);
-}
-
-function normalizeOneEntityRef(entry: unknown): Record<string, string> | null {
-  if (typeof entry === 'string') {
-    const trimmed = entry.trim();
-    return trimmed ? { ref: trimmed } : null;
-  }
-  if (!entry || typeof entry !== 'object') return null;
-  const obj = entry as Record<string, unknown>;
-  const atId = typeof obj['@id'] === 'string' ? (obj['@id'] as string) : null;
-  const explicitRef = typeof obj.ref === 'string' ? obj.ref
-    : typeof obj.entityId === 'string' ? obj.entityId
-    : typeof obj.entity_id === 'string' ? obj.entity_id
-    : null;
-  const entityId = (atId ? lastPathSegment(atId) : null) ?? explicitRef;
-  if (!entityId) return null;
-  const out: Record<string, string> = { ref: entityId };
-  const displayRaw = obj[GL.DISPLAY] ?? obj['gloss:display'] ?? obj.display;
-  if (typeof displayRaw === 'string') out.display = displayRaw;
-  return out;
-}
-
-function lastPathSegment(p: string): string | null {
-  const cleaned = p.replace(/[?#].*$/, '').replace(/\/+$/, '');
-  const segments = cleaned.split('/');
-  const last = segments[segments.length - 1];
-  return last ? decodeURIComponent(last) : null;
-}

package/src/adapters/model-bridge/hyperedge.ts

@@ -1,103 +0,0 @@
-/**
- * Hyperedge (n-ary relation) mapping: JSON-LD → glossarist-js model.
- *
- * Handles ISO 704:2022 n-ary relations — both PartitiveHyperedge and
- * GenericHyperedge share the same JSON-LD wire shape. The mapper is
- * identical for both; the glossarist-js Concept constructor dispatches
- * by wire key (`partitive_relations` vs `generic_relations`).
- *
- * MECE migration: reads presence × count directly (ISO 704:2022 v3).
- * Falls back to migrating the legacy 5-value `multiplicity` or v2
- * `certainty` field.
- */
-import { GL } from '../wire-keys';
-import { isPartitivePresence, isPartitiveCount } from '../../utils/partitive-multiplicity';
-import { mapRefFromJsonLd } from './mappers';
-import type { JsonLdPartitiveRelation } from './jsonld-types';
-
-/**
- * Map a JSON-LD relation entry to the raw dict shape that
- * glossarist-js's AbstractHyperedge subclasses accept.
- *
- * Works for both PartitiveHyperedge and GenericHyperedge — the only
- * difference at the wire level is which wire key the parent dict
- * uses (`partitive_relations` vs `generic_relations`).
- *
- * Reads `gl:hasPartitive`, `gl:hasGeneric`, or `gl:members` for
- * the member array (in order of preference).
- */
-export function mapHyperedgeFromJsonLd(
-  r: JsonLdPartitiveRelation,
-  memberKey: 'gl:hasPartitive' | 'gl:hasGeneric' | 'gl:members' = 'gl:hasPartitive',
-): Record<string, unknown> | null {
-  const comprehensive = r[GL.COMPREHENSIVE] ? mapRefFromJsonLd(r[GL.COMPREHENSIVE]) : null;
-  if (!comprehensive) return null;
-
-  const rawMembers = r[GL.HAS_PARTITIVE] ?? r[GL.HAS_GENERIC] ?? r[GL.HAS_MEMBER] ?? r[memberKey] ?? [];
-  const partitives = (rawMembers as any[])
-    .map((m): Record<string, unknown> | null => {
-      const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
-      if (!ref) return null;
-      const out: Record<string, unknown> = { ref };
-      const presence = m[GL.PRESENCE];
-      const count = m[GL.COUNT];
-      if (isPartitivePresence(presence) && isPartitiveCount(count)) {
-        out.presence = presence;
-        out.count = count;
-      } else {
-        const raw = m[GL.MULTIPLICITY] ?? splitLegacyCertainty(m[GL.CERTAINTY]);
-        if (raw) {
-          const parts = splitMultiplicity(raw);
-          out.presence = parts.presence;
-          out.count = parts.count;
-        }
-      }
-      if (m[GL.IS_DELIMITING] === true) out.is_delimiting = true;
-      // ISO 704:2022 §5.5.4.2.1 — GenericMember carries a required
-      // delimitingCharacteristic (the intension difference between
-      // this specific concept and its coordinate concepts).
-      const dc = m[GL.DELIMITING_CHARACTERISTIC];
-      if (dc) {
-        out.delimitingCharacteristic = typeof dc === 'string'
-          ? { default: dc }
-          : dc;
-      }
-      return out;
-    })
-    .filter((m): m is Record<string, unknown> => m !== null);
-
-  if (partitives.length < 2) return null;
-
-  const out: Record<string, unknown> = {
-    comprehensive,
-    members: partitives,
-  };
-
-  if (r[GL.COMPLETENESS]) out.completeness = r[GL.COMPLETENESS];
-
-  if (r[GL.CRITERION]) {
-    out.criterion = typeof r[GL.CRITERION] === 'string'
-      ? { default: r[GL.CRITERION] }
-      : r[GL.CRITERION];
-  }
-
-  return out;
-}
-
-/** Migrate legacy v2 certainty → old v3 multiplicity string. */
-function splitLegacyCertainty(certainty: string | undefined): string | null {
-  if (!certainty) return null;
-  return certainty === 'possible' ? 'optional' : 'compulsory';
-}
-
-/** Split the legacy one-string multiplicity into MECE presence × count. */
-function splitMultiplicity(m: string): { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' } {
-  const LEGACY_MAP: Record<string, { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' }> = {
-    compulsory:               { presence: 'required', count: 'exactly_one' },
-    optional:                 { presence: 'optional', count: 'exactly_one' },
-    compulsory_multiple:      { presence: 'required', count: 'multiple' },
-    optional_multiple:        { presence: 'optional', count: 'multiple' },
-    compulsory_at_least_one:  { presence: 'required', count: 'at_least_one' },
-  };
-  return LEGACY_MAP[m] ?? { presence: 'required', count: 'exactly_one' };
-}

package/src/adapters/model-bridge/index.ts

@@ -1,46 +0,0 @@
-/**
- * Model bridge: converts between wire-format JSON and glossarist-js
- * model instances.
- *
- * Supports two input formats:
- * 1. JSON-LD (gl:-prefixed) — format produced by generate-data.mjs
- * 2. Glossarist native — snake_case format from glossarist-js Concept.toJSON()
- *
- * Public API is re-exported here. Internal organization:
- *   - jsonld-types.ts  — wire-format interface declarations
- *   - bridges.ts       — WeakMap bridges for fields not yet in glossarist-js
- *   - mappers.ts       — JSON-LD → snake_case mappers
- *   - partitive.ts     — PartitiveRelation mapping + MECE migration
- *   - entity-refs.ts   — non-verbal entity reference normalization
- *   - concept.ts       — top-level Concept orchestration + URI construction
- */
-export {
-  conceptFromJson,
-  conceptToSummary,
-  conceptUri,
-} from './concept';
-
-export {
-  getAnnotations,
-  getDesignationTarget,
-  getRefText,
-  getRelatedSourceId,
-  getRelatedCitation,
-} from './bridges';
-
-export type {
-  JsonLdConcept,
-  JsonLdLocalizedConcept,
-  JsonLdPartitiveMember,
-  JsonLdPartitiveRelation,
-  JsonLdDesignation,
-  JsonLdSource,
-  JsonLdOrigin,
-  JsonLdRelated,
-  JsonLdRef,
-  JsonLdLocality,
-  JsonLdDate,
-  JsonLdContent,
-  JsonLdPronunciation,
-  JsonLdGrammarInfo,
-} from './jsonld-types';