glossarist 0.3.3 → 0.3.5

package/src/reference-mention.js

@@ -0,0 +1,88 @@
+/**
+ * Mention parser for {{...}} inline references in concept text.
+ *
+ * Pure function: takes a raw mention body (the text inside
+ * {{...}}) and returns a structured MentionParseResult. The
+ * extractor (in src/reference-resolver.js) consumes the
+ * structured form to emit Reference objects.
+ *
+ * Two outcomes in v8:
+ *  - 'cite-ref': the mention is {{cite:<key>}} or
+ *    {{cite:<key>,<label>}}. The extractor looks the key up in
+ *    the current concept's sources list.
+ *  - 'numeric': the mention is a bare dotted or dashed id
+ *    like {{3.1.1.1}} or {{103-01-02}}. Resolves to a
+ *    same-dataset concept.
+ *  - 'unresolved': the mention did not match a recognized
+ *    form. The extractor silently drops it.
+ *
+ * The full v6 form-aware parser (URI schemes, short-ids,
+ * quoting) is aspirational; v8 only supports the two forms
+ * above plus a catch-all unresolved case.
+ *
+ * @typedef {Object} MentionParseResult
+ * @property {'cite-ref' | 'numeric' | 'unresolved'} kind
+ * @property {string} [key]   — for 'cite-ref': the local key
+ * @property {string} [label] — for 'cite-ref': the inline label
+ * @property {string} [id]    — for 'numeric': the bare id
+ * @property {string} raw     — the original mention body
+ */
+
+const NUMERIC_RE = /^\d+(?:[.-]\d+)+$/;
+
+/**
+ * Parse the body of a {{...}} mention (without the braces).
+ *
+ * The function is pure: no I/O, no model lookups, no state.
+ * Resolution of the parsed result is the extractor's job.
+ *
+ * @param {string} raw — the trimmed text inside {{...}}
+ * @returns {MentionParseResult}
+ */
+export function parseMention(raw) {
+  const body = raw.trim();
+
+  // 1. cite:<key> form, with optional ,<label> after the key.
+  //    The key must not contain a comma (the comma is the
+  //    label separator). Labels can be quoted (CSV-style) to
+  //    contain commas; if not quoted, the label is the text
+  //    up to the next comma or the end of the mention. The
+  //    label may be empty.
+  const citeMatch = body.match(/^cite:([^,}]+)(?:,(.*))?$/);
+  if (citeMatch) {
+    const label = citeMatch[2] !== undefined ? unquoteLabel(citeMatch[2].trim()) : null;
+    return {
+      kind: 'cite-ref',
+      key: citeMatch[1].trim(),
+      label,
+      raw: body,
+    };
+  }
+
+  // 2. Bare numeric id: same-dataset concept id.
+  if (NUMERIC_RE.test(body)) {
+    return {
+      kind: 'numeric',
+      id: body,
+      raw: body,
+    };
+  }
+
+  // 3. Anything else is unresolved at the parse layer.
+  return {
+    kind: 'unresolved',
+    raw: body,
+  };
+}
+
+/**
+ * Strip surrounding double quotes from a label, unescaping
+ * CSV-style "" to a single ". If the input is not quoted,
+ * return it unchanged.
+ */
+function unquoteLabel(label) {
+  if (label.length >= 2 && label.startsWith('"') && label.endsWith('"')) {
+    return label.slice(1, -1).replace(/""/g, '"');
+  }
+  return label;
+}

package/src/reference-resolver.js

@@ -1,11 +1,35 @@
 import { ConceptRef } from './models/concept-ref.js';
+import { parseMention } from './reference-mention.js';
 
 export class Reference {
-  constructor(type, target, relationship, source) {
+  /**
+   * @param {string} type — the structural kind of the reference
+   *   ('concept', 'dataset', 'bibliography', 'typed-ref',
+   *   'standard').
+   * @param {string | null} target — the legacy flat display
+   *   string. Kept for backward compat with callers that only
+   *   read `r.target`.
+   * @param {string | null} [relationship] — the type of the
+   *   relationship that produced this reference (e.g. 'see',
+   *   'supersedes', 'source').
+   * @param {string | null} [source] — a JSON-pointer-ish path
+   *   indicating where in the concept the reference was
+   *   extracted from.
+   * @param {object} [extras] — additional fields (v8+):
+   *   `citation`, `sourceId`, `resolution`, `lookupKey`,
+   *   `label`, `quoted`, `uri`. All optional.
+   */
+  constructor(type, target, relationship, source, extras = {}) {
     this.type = type;
     this.target = target;
     this.relationship = relationship ?? null;
     this.source = source ?? null;
+
+    this.uri = extras.uri ?? null;
+    this.citation = extras.citation ?? null;
+    this.sourceId = extras.sourceId ?? null;
+    this.resolution = extras.resolution ?? null;
+    this.lookupKey = extras.lookupKey ?? null;
   }
 }
 
@@ -18,6 +42,21 @@ function refTarget(rc) {
 }
 
 export class ReferenceResolver {
+  /**
+   * Extract all embedded references from a concept's localizations.
+   *
+   * Walks definitions, notes, examples, and annotations text.
+   * For each `{{...}}` mention, runs `parseMention` to
+   * classify the form, then dispatches:
+   *   - 'cite-ref'  → look up the key in concept.sources; emit
+   *                   Bibliography Reference with the Citation.
+   *   - 'numeric'   → emit Concept Reference with the bare id
+   *                   (existing behavior).
+   *   - 'unresolved' → do not emit a Reference.
+   *
+   * @param {Concept} concept
+   * @returns {Reference[]}
+   */
   extractReferences(concept) {
     const refs = [];
 
@@ -42,47 +81,267 @@ export class ReferenceResolver {
         }
       }
 
-      const texts = [
-        ...(lc.definitions?.map(d => d.content ?? '') ?? []),
-        ...(lc.notes?.map(n => typeof n === 'object' ? (n.content ?? '') : String(n)) ?? []),
-      ];
-      for (const text of texts) {
-        refs.push(..._extractEmbedded(text));
+      const texts = this._collectTexts(lc, lang);
+      for (const { text, source } of texts) {
+        for (const ref of this._extractFromText(text, source, concept)) {
+          refs.push(ref);
+        }
       }
     }
 
     return refs;
   }
 
-  resolveReference(ref, collection) {
-    if (ref.type !== 'concept') return null;
-    return collection.byId(ref.target);
+  /**
+   * Collect all text fields from a localized concept, paired
+   * with diagnostic source paths.
+   *
+   * @param {LocalizedConcept} lc
+   * @param {string} lang
+   * @returns {{text: string, source: string}[]}
+   */
+  _collectTexts(lc, lang) {
+    const out = [];
+    for (let i = 0; (lc.definitions ?? [])[i]; i++) {
+      const content = lc.definitions[i]?.content;
+      if (typeof content === 'string') {
+        out.push({ text: content, source: `localizations.${lang}.definitions[${i}].content` });
+      }
+    }
+    for (let i = 0; (lc.notes ?? [])[i]; i++) {
+      const content = typeof lc.notes[i] === 'object'
+        ? (lc.notes[i]?.content ?? '')
+        : String(lc.notes[i] ?? '');
+      if (content) {
+        out.push({ text: content, source: `localizations.${lang}.notes[${i}].content` });
+      }
+    }
+    for (let i = 0; (lc.examples ?? [])[i]; i++) {
+      const content = lc.examples[i]?.content;
+      if (typeof content === 'string') {
+        out.push({ text: content, source: `localizations.${lang}.examples[${i}].content` });
+      }
+    }
+    for (let i = 0; (lc.annotations ?? [])[i]; i++) {
+      const content = lc.annotations[i]?.content;
+      if (typeof content === 'string') {
+        out.push({ text: content, source: `localizations.${lang}.annotations[${i}].content` });
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Walk a single text string and emit References for each
+   * `{{...}}` mention.
+   *
+   * @param {string} text
+   * @param {string} source — diagnostic path
+   * @param {Concept} concept — the owning concept (for cite-ref lookup)
+   * @returns {Reference[]}
+   */
+  _extractFromText(text, source, concept) {
+    const refs = [];
+    const re = /\{\{([^{}]*?)\}\}/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const parsed = parseMention(m[1]);
+      switch (parsed.kind) {
+        case 'cite-ref':
+          refs.push(this._resolveCiteRef(parsed, source, concept));
+          break;
+        case 'numeric':
+          refs.push(new Reference('concept', parsed.id, 'embedded', source));
+          break;
+        case 'unresolved':
+          // Silently dropped. The mention is either non-reference
+          // text (e.g. math, code) or a form we don't support.
+          break;
+      }
+    }
+    return refs;
+  }
+
+  /**
+   * Resolve a `cite-ref` parser result against the concept's
+   * sources list. Emits a Bibliography Reference with the
+   * resolved Citation (if found) or an unresolved Reference
+   * (if not).
+   *
+   * @param {MentionParseResult} parsed
+   * @param {string} source — diagnostic path
+   * @param {Concept} concept — the owning concept
+   * @returns {Reference}
+   */
+  _resolveCiteRef(parsed, source, concept) {
+    const sourceEntry = concept?.findSourceById(parsed.key) ?? null;
+    if (!sourceEntry) {
+      return new Reference(
+        'bibliography',
+        parsed.label ?? parsed.key,
+        null,
+        source,
+        {
+          sourceId: parsed.key,
+          citation: null,
+          resolution: { kind: 'unresolved', reason: 'no-source' },
+        },
+      );
+    }
+    const displayTarget = parsed.label
+      ?? sourceEntry.origin?.toString()
+      ?? sourceEntry.id;
+    return new Reference(
+      'bibliography',
+      displayTarget,
+      null,
+      source,
+      {
+        sourceId: sourceEntry.id,
+        citation: sourceEntry.origin,
+        resolution: { kind: 'resolved', sourceId: sourceEntry.id },
+      },
+    );
+  }
+
+  /**
+   * Resolve a single reference against a registry (a map of
+   * datasetId → { concepts, register? }). The registry may also
+   * include 'bibliography:<source>' keys for bibliographic
+   * datasets.
+   *
+   * For a `type: 'bibliography'` Reference with an inline
+   * `citation`, the resolver first tries the bibliography
+   * registry (matching `citation.ref` by source/id/version);
+   * if not found, returns the inline Citation as a
+   * self-contained fallback.
+   *
+   * For a `type: 'bibliography'` Reference with a `uri` and
+   * `resolution.kind === 'bibliography-namespace'`, the
+   * resolver tries the bibliography registry by
+   * `resolution.source/id/version`.
+   *
+   * For `type: 'concept'` References with a `lookupKey.id`
+   * (id-match, short-id, or numeric), the resolver looks up
+   * the id in `lookupKey.dataset`'s ConceptCollection.
+   *
+   * Backward compat: when the second argument is a
+   * ConceptCollection (has `byId` but no `concepts` field), it
+   * is treated as a one-key registry of one default dataset.
+   */
+  resolveReference(ref, registry) {
+    if (ref == null) return null;
+
+    // Backward-compat: single ConceptCollection becomes a
+    // one-key registry.
+    if (isConceptCollection(registry)) {
+      registry = { _default: { concepts: registry } };
+    }
+    if (registry == null) return null;
+
+    // 1. cite:key form (Bibliography with inline Citation).
+    if (ref.type === 'bibliography' && ref.citation) {
+      const bioRecord = this._resolveBibliographyRecord(
+        ref.citation.ref,
+        registry,
+      );
+      if (bioRecord) return bioRecord;
+      return ref.citation;
+    }
+
+    // 2. URI form (urn:... or https:...) with
+    //    bibliography-namespace resolution.
+    if (ref.uri) {
+      if (ref.resolution?.kind === 'bibliography-namespace'
+          || (ref.resolution?.source && !ref.resolution?.datasetId)) {
+        const bioRecord = this._resolveBibliographyRecord(
+          ref.resolution,
+          registry,
+        );
+        if (bioRecord) return bioRecord;
+      }
+      // Concept URI lookup (for non-bibliography URIs).
+      if (ref.resolution?.datasetId) {
+        const coll = registry[ref.resolution.datasetId]?.concepts;
+        if (coll) {
+          return coll.byId(ref.resolution.conceptId);
+        }
+      }
+      return null;
+    }
+
+    // 3. Same-dataset concept id (numeric mention, id-match, etc.).
+    if (ref.lookupKey?.id) {
+      const coll = registry[ref.lookupKey.dataset]?.concepts;
+      if (coll) return coll.byId(ref.lookupKey.id);
+      return null;
+    }
+
+    // 3b. Backward-compat: a concept ref with a `target` (id)
+    //     but no `lookupKey` is looked up in the single
+    //     collection (backward-compat one-key registry).
+    if (ref.type === 'concept' && ref.target) {
+      const defaultColl = registry._default?.concepts;
+      if (defaultColl) return defaultColl.byId(ref.target);
+      // Try every dataset in the registry as a fallback.
+      for (const entry of Object.values(registry)) {
+        if (entry?.concepts?.byId(ref.target)) {
+          return entry.concepts.byId(ref.target);
+        }
+      }
+      return null;
+    }
+
+    // 4. Unanchored designation — search is a separate concern
+    //    (plan 06). For v8, return null.
+    if (ref.lookupKey?.designation) {
+      return null;
+    }
+
+    return null;
+  }
+
+  /**
+   * Try to resolve a Citation::Ref against the bibliography
+   * registry. The ref has shape { source, id, version? }.
+   *
+   * Returns the matching bibliographic record (a Concept), or
+   * null if no match.
+   */
+  _resolveBibliographyRecord(citationRef, registry) {
+    if (!citationRef?.source || !citationRef?.id) return null;
+    const bioColl = registry[`bibliography:${citationRef.source}`]?.concepts;
+    if (!bioColl) return null;
+    if (citationRef.version) {
+      return bioColl.byIdAnd(citationRef.id, citationRef.version);
+    }
+    return bioColl.byId(citationRef.id);
   }
 
-  resolveAll(concept, collection) {
+  resolveAll(concept, registry) {
     const resolved = new Map();
     for (const ref of this.extractReferences(concept)) {
-      if (ref.type === 'concept') {
-        resolved.set(ref.target, this.resolveReference(ref, collection));
+      if (ref.type === 'concept' || ref.type === 'bibliography') {
+        const target = this.resolveReference(ref, registry);
+        if (target != null) {
+          const key = ref.target ?? ref.uri ?? ref.sourceId;
+          if (key != null) resolved.set(key, target);
+        }
       }
     }
     return resolved;
   }
 }
 
-const CONCEPT_REF_RE = /\{\{([^}]+)\}\}|\b(\d+(?:\.\d+)+)\b/g;
-
-function _extractEmbedded(text) {
-  const refs = [];
-  let m;
-  CONCEPT_REF_RE.lastIndex = 0;
-  while ((m = CONCEPT_REF_RE.exec(text)) !== null) {
-    const target = m[1] ?? m[2];
-    if (target && /^\d+(\.\d+)+$/.test(target)) {
-      refs.push(new Reference('concept', target, 'embedded', null));
-    }
-  }
-  return refs;
+/**
+ * Type-guard for the single-collection case (backward compat).
+ * A ConceptCollection has `byId` but no `concepts` field.
+ */
+function isConceptCollection(x) {
+  return x != null
+    && typeof x === 'object'
+    && typeof x.byId === 'function'
+    && !('concepts' in x);
 }
 
 export const referenceResolver = new ReferenceResolver();

package/src/render-classification.js

@@ -0,0 +1,106 @@
+/**
+ * Classify a Reference for rendering.
+ *
+ * The classifier is constructed once per render with a registry
+ * (and optional source dataset id). The classify() method is
+ * pure and side-effect-free.
+ *
+ * Each `Reference.type` is its own `_classifyXxx` method. The
+ * dispatch in classify() is closed for modification.
+ */
+
+export class ReferenceClassifier {
+  /**
+   * @param {object} registry — the deployment's dataset registry.
+   * @param {string} [sourceDatasetId] — the dataset the source
+   *   concept belongs to; used to determine "same-dataset".
+   * @param {object} [options] — additional options (e.g. scope).
+   */
+  constructor(registry = {}, sourceDatasetId = null, options = {}) {
+    this.registry = registry;
+    this.sourceDatasetId = sourceDatasetId;
+    this.options = options;
+  }
+
+  /**
+   * @param {Reference} ref
+   * @returns {string} — the classification (e.g. 'same-dataset',
+   *   'internal-citation', 'unresolved', etc.)
+   */
+  classify(ref) {
+    if (ref == null) return 'unknown';
+
+    switch (ref.type) {
+      case 'concept':    return this._classifyConcept(ref);
+      case 'dataset':    return this._classifyDataset(ref);
+      case 'bibliography': return this._classifyBibliography(ref);
+      case 'typed-ref':  return this._classifyTypedRef(ref);
+      case 'standard':   return 'legacy-standard';
+      default:           return 'unknown';
+    }
+  }
+
+  _classifyConcept(ref) {
+    // 1. URI form, resolved to a dataset.
+    if (ref.uri) {
+      const dsId = ref.resolution?.datasetId;
+      if (!dsId) return 'unresolved';
+      if (!this.registry[dsId]) return 'external-citation';
+      if (dsId === this.sourceDatasetId) return 'same-dataset';
+      return 'cross-dataset';
+    }
+    // 2. Unanchored designation.
+    if (ref.lookupKey?.designation) {
+      return 'unresolved-designation';
+    }
+    // 3. Id-style (id-match, short-id, numeric).
+    if (ref.lookupKey?.id) {
+      const dsId = ref.lookupKey.dataset;
+      if (!this.registry[dsId]) return 'unresolved';
+      if (dsId === this.sourceDatasetId) return 'same-dataset';
+      return 'cross-dataset';
+    }
+    // 4. Concept ref with target (legacy).
+    if (ref.target) {
+      return 'unresolved';
+    }
+    return 'unresolved';
+  }
+
+  _classifyDataset(ref) {
+    if (ref.resolution?.kind === 'dataset-self') return 'dataset-self';
+    if (ref.resolution?.kind === 'dataset-namespace') return 'dataset-self';
+    return 'unknown';
+  }
+
+  _classifyBibliography(ref) {
+    // 1. cite:key form: try the bibliography registry.
+    if (ref.citation) {
+      const bioRecord = this._tryBibliography(ref.citation.ref);
+      if (bioRecord) return 'internal-citation';
+      return 'self-contained-citation';
+    }
+    // 2. URI form: try the bibliography registry, then the
+    //    resolution's datasetId (if it's a concept URI), else null.
+    if (ref.uri) {
+      const bioRecord = this._tryBibliography(ref.resolution);
+      if (bioRecord) return 'internal-citation';
+      return 'external-citation';
+    }
+    return 'unresolved-citation';
+  }
+
+  _classifyTypedRef(_ref) {
+    return 'typed-ref';
+  }
+
+  _tryBibliography(citationRef) {
+    if (!citationRef?.source || !citationRef?.id) return null;
+    const bioColl = this.registry[`bibliography:${citationRef.source}`]?.concepts;
+    if (!bioColl) return null;
+    if (citationRef.version) {
+      return bioColl.byIdAnd(citationRef.id, citationRef.version) ?? null;
+    }
+    return bioColl.byId(citationRef.id) ?? null;
+  }
+}

package/src/validators/concept-validator.js

@@ -1,5 +1,5 @@
 import { ValidationRule } from './validation-rule.js';
-import { ValidationError } from './validation-error.js';
+import { ValidationResult } from './validation-result.js';
 
 const VALID_DESIGNATION_TYPES = new Set([
   'expression', 'abbreviation', 'symbol', 'graphical symbol', 'graphical_symbol',
@@ -9,51 +9,55 @@ const VALID_ENTRY_STATUSES = new Set([
   'valid', 'draft', 'retired', 'notValid', 'superseded', 'withdrawn',
 ]);
 
+const _langs = (c) =>
+  c.languages ?? (c.localizations ? Object.keys(c.localizations) : []);
+
+const _loc = (c, lang) =>
+  typeof c.localization === 'function' ? c.localization(lang) : c.localizations?.[lang];
+
 export class LanguageCodeRule extends ValidationRule {
   constructor() { super('language-code'); }
-  validate(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const lang of Object.keys(value.localizations)) {
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
       if (!/^[a-z]{3}$/.test(lang)) {
-        errors.push(...this.error(`${path}localizations.${lang}`,
-          `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`));
+        result.addError(`${path}localizations.${lang}`,
+          `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`);
       }
     }
-    return errors;
   }
 }
 
 export class DesignationTypeRule extends ValidationRule {
   constructor() { super('designation-type'); }
-  validate(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const [lang, lc] of Object.entries(value.localizations)) {
-      for (let i = 0; i < (lc.terms?.length ?? 0); i++) {
-        const t = lc.terms[i];
-        if (t.type && !VALID_DESIGNATION_TYPES.has(t.type)) {
-          errors.push(...this.error(`${path}localizations.${lang}.terms[${i}].type`,
-            `Unknown designation type '${t.type}'`));
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
+      const lc = _loc(concept, lang);
+      if (!lc) continue;
+      const terms = lc.terms ?? [];
+      for (let i = 0; i < terms.length; i++) {
+        const t = terms[i];
+        const type = t.type ?? (typeof t.toJSON === 'function' ? t.toJSON().type : undefined);
+        if (type && !VALID_DESIGNATION_TYPES.has(type)) {
+          result.addError(`${path}localizations.${lang}.terms[${i}].type`,
+            `Unknown designation type '${type}'`);
         }
       }
     }
-    return errors;
   }
 }
 
 export class EntryStatusRule extends ValidationRule {
   constructor() { super('entry-status'); }
-  validate(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const [lang, lc] of Object.entries(value.localizations)) {
-      if (lc.entry_status && !VALID_ENTRY_STATUSES.has(lc.entry_status)) {
-        errors.push(...this.error(`${path}localizations.${lang}.entry_status`,
-          `Unknown entry status '${lc.entry_status}'`));
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
+      const lc = _loc(concept, lang);
+      if (!lc) continue;
+      const status = lc.entryStatus ?? lc.entry_status;
+      if (status && !VALID_ENTRY_STATUSES.has(status)) {
+        result.addError(`${path}localizations.${lang}.entry_status`,
+          `Unknown entry status '${status}'`);
       }
     }
-    return errors;
   }
 }
 
@@ -66,34 +70,37 @@ export class ConceptValidator {
   }
 
   validate(concept) {
-    const errors = [];
-    const json = typeof concept.toJSON === 'function' ? concept.toJSON() : concept;
+    const result = new ValidationResult();
+    const hasModelApi = typeof concept.localization === 'function';
 
-    if (!json.id) {
-      errors.push(new ValidationError('id', 'Concept must have an id'));
+    if (!concept.id) {
+      result.addError('id', 'Concept must have an id');
     }
-    if (!json.localizations || Object.keys(json.localizations).length === 0) {
-      errors.push(new ValidationError('localizations',
-        'Concept must have at least one localization', 'warning'));
+
+    const langs = hasModelApi ? concept.languages : Object.keys(concept.localizations ?? {});
+    if (langs.length === 0) {
+      result.addWarning('localizations', 'Concept must have at least one localization');
+    } else if (hasModelApi) {
+      for (const lang of langs) {
+        const lc = concept.localization(lang);
+        if (!lc || lc.terms.length === 0) {
+          result.addWarning(`localizations.${lang}.terms`,
+            `Localization '${lang}' must have at least one term`);
+        }
+      }
     } else {
-      for (const [lang, lc] of Object.entries(json.localizations)) {
+      for (const [lang, lc] of Object.entries(concept.localizations ?? {})) {
         if (!lc.terms || lc.terms.length === 0) {
-          errors.push(new ValidationError(
-            `localizations.${lang}.terms`,
-            `Localization '${lang}' must have at least one term`, 'warning'));
+          result.addWarning(`localizations.${lang}.terms`,
+            `Localization '${lang}' must have at least one term`);
         }
       }
     }
 
     for (const rule of this._rules) {
-      errors.push(...rule.validate(json, ''));
+      rule.validate(concept, '', result);
     }
 
-    return {
-      valid: errors.filter(e => e.severity === 'error').length === 0,
-      errors: errors.filter(e => e.severity === 'error'),
-      warnings: errors.filter(e => e.severity === 'warning'),
-    };
+    return result;
   }
 }
-