glossarist 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",

package/src/index.d.ts

@@ -35,8 +35,9 @@ export { conceptUuid, localizedConceptUuid, uuidV5 } from './uuid';
 export { ReferenceResolver, Reference, referenceResolver } from './reference-resolver';
 
 export type MentionParseResult = {
-  kind: 'cite-ref' | 'numeric' | 'unresolved';
+  kind: 'cite-ref' | 'urn-ref' | 'numeric' | 'designation' | 'unresolved';
   key?: string;
+  uri?: string;
   label?: string | null;
   id?: string;
   raw: string;

package/src/reference-mention.js

@@ -2,29 +2,26 @@
  * 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.
+ * {{...}}) and returns a structured MentionParseResult.
  *
- * 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.
+ * Convention: the ID always comes first, the display (render) text
+ * always comes last.  Every comma-separated form follows this:
  *
- * 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.
+ *   {{cite:key}}                  cite-key (source id)
+ *   {{cite:key, render term}}     cite-key + render term
+ *   {{urn:...}}                   URN reference
+ *   {{urn:..., render term}}      URN + render term
+ *   {{numeric_id}}                local concept ID
+ *   {{numeric_id, render term}}   local concept ID + render term
+ *   {{designation}}               designation matching
+ *   {{designation, render term}}  designation + render term
  *
  * @typedef {Object} MentionParseResult
- * @property {'cite-ref' | 'numeric' | 'unresolved'} kind
+ * @property {'cite-ref' | 'urn-ref' | 'numeric' | 'designation' | '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} [uri]   — for 'urn-ref': the URN
+ * @property {string} [label] — render text (always last)
+ * @property {string} [id]    — for 'numeric' / 'designation': the id
  * @property {string} raw     — the original mention body
  */
 
@@ -42,12 +39,7 @@ const NUMERIC_RE = /^\d+(?:[.-]\d+)+$/;
 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.
+  // 1. cite:<key>[,render] — explicit citation reference.
   const citeMatch = body.match(/^cite:([^,}]+)(?:,(.*))?$/);
   if (citeMatch) {
     const label = citeMatch[2] !== undefined ? unquoteLabel(citeMatch[2].trim()) : null;
@@ -59,20 +51,38 @@ export function parseMention(raw) {
     };
   }
 
-  // 2. Bare numeric id: same-dataset concept id.
-  if (NUMERIC_RE.test(body)) {
+  // 2. urn:...[,render] — URN reference.
+  const urnMatch = body.match(/^(urn:[^,}]+)(?:,(.*))?$/);
+  if (urnMatch) {
+    const label = urnMatch[2] !== undefined ? unquoteLabel(urnMatch[2].trim()) : null;
     return {
-      kind: 'numeric',
-      id: body,
+      kind: 'urn-ref',
+      uri: urnMatch[1].trim(),
+      label,
       raw: body,
     };
   }
 
-  // 3. Anything else is unresolved at the parse layer.
-  return {
-    kind: 'unresolved',
-    raw: body,
-  };
+  // 3. Comma-separated form: {{id, render}}.
+  //    ID always comes first, render text always comes last.
+  const commaIdx = body.indexOf(',');
+  if (commaIdx !== -1) {
+    const id = body.slice(0, commaIdx).trim();
+    const label = unquoteLabel(body.slice(commaIdx + 1).trim());
+
+    if (NUMERIC_RE.test(id)) {
+      return { kind: 'numeric', id, label, raw: body };
+    }
+    return { kind: 'designation', id, label, raw: body };
+  }
+
+  // 4. Bare numeric id.
+  if (NUMERIC_RE.test(body)) {
+    return { kind: 'numeric', id: body, label: null, raw: body };
+  }
+
+  // 5. Anything else is unresolved at the parse layer.
+  return { kind: 'unresolved', raw: body };
 }
 
 /**

package/src/reference-resolver.js

@@ -150,12 +150,23 @@ export class ReferenceResolver {
         case 'cite-ref':
           refs.push(this._resolveCiteRef(parsed, source, concept));
           break;
+        case 'urn-ref':
+          refs.push(new Reference('concept', parsed.label ?? parsed.uri, 'embedded', source, {
+            uri: parsed.uri,
+            resolution: null,
+          }));
+          break;
         case 'numeric':
-          refs.push(new Reference('concept', parsed.id, 'embedded', source));
+          refs.push(new Reference('concept', parsed.label ?? parsed.id, 'embedded', source, {
+            lookupKey: { id: parsed.id },
+          }));
+          break;
+        case 'designation':
+          refs.push(new Reference('concept', parsed.label ?? parsed.id, 'embedded', source, {
+            lookupKey: { designation: parsed.id },
+          }));
           break;
         case 'unresolved':
-          // Silently dropped. The mention is either non-reference
-          // text (e.g. math, code) or a form we don't support.
           break;
       }
     }