glossarist 0.4.27 → 0.4.28

package/package.json

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

package/src/diff/diff-renderer.js

@@ -1,4 +1,5 @@
 import { TextDiff } from './text-diff.js';
+import { resolveMultiplicity } from '../models/multiplicity.js';
 
 const COLORS = {
   red: s => `\x1b[31m${s}\x1b[0m`,
@@ -198,16 +199,6 @@ function definitionLabel(d) {
   return d.content ?? '?';
 }
 
-import { multiplicityFromPair } from '../models/multiplicity.js';
-
-function _resolveMultiplicity(m) {
-  if (m?.presence && m?.count) {
-    try { return multiplicityFromPair(m.presence, m.count); }
-    catch { return 'compulsory'; }
-  }
-  return m?.multiplicity ?? 'compulsory';
-}
-
 function relationLabel(r) {
   if (!r) return '?';
   const c = r.comprehensive;
@@ -216,7 +207,7 @@ function relationLabel(r) {
     ? r.partitives.map(m => {
         const ref = m?.ref ?? m ?? {};
         let tail = '';
-        const mult = _resolveMultiplicity(m);
+        const mult = resolveMultiplicity(m);
         if (mult && mult !== 'compulsory') tail = ` (${mult})`;
         if (m?.is_delimiting === true) tail += ' ⊘';
         return `${ref.id ?? ref.source ?? ref.text ?? '?'}${tail}`;
@@ -246,7 +237,7 @@ export function multiplicityStats(relations) {
   for (const rel of relations ?? []) {
     for (const m of rel?.partitives ?? []) {
       total += 1;
-      const mult = _resolveMultiplicity(m);
+      const mult = resolveMultiplicity(m);
       byMultiplicity[mult] = (byMultiplicity[mult] ?? 0) + 1;
       const p = m?.presence ?? 'required';
       const c = m?.count ?? 'exactly_one';

package/src/models/index.js

@@ -63,6 +63,7 @@ export {
   isValidMultiplicity,
   multiplicityFromPair,
   pairFromMultiplicity,
+  resolveMultiplicity,
 } from './multiplicity.js';
 
 // v1 → v2 migration helper. Pure function; idempotent.

package/src/models/multiplicity.js

@@ -66,6 +66,32 @@ export function isValidMultiplicity(name) {
   return Object.prototype.hasOwnProperty.call(PAIR_BY_NAME, name);
 }
 
+/**
+ * Resolve the ISO 704 multiplicity name from any object carrying
+ * `presence` + `count`, OR a legacy object that still has a literal
+ * `multiplicity` field (pre-v4 JSON).
+ *
+ * For v4 `PartitiveMember` instances, `presence` + `count` are always
+ * set (defaults applied at construction), so the legacy branch never
+ * fires on a real instance — it exists purely to round-trip raw JSON
+ * that bypassed the model constructor.
+ *
+ * Throws on the invalid `(optional, at_least_one)` combination — the
+ * model already rejects this at construction, so reaching the throw
+ * here means the caller bypassed the model. Let the error propagate
+ * rather than silently returning 'compulsory' (which would mask the
+ * data corruption).
+ */
+export function resolveMultiplicity(member) {
+  if (member?.presence && member?.count) {
+    return multiplicityFromPair(member.presence, member.count);
+  }
+  if (typeof member?.multiplicity === 'string') {
+    return member.multiplicity;
+  }
+  return DEFAULT_MULTIPLICITY;
+}
+
 function invalidCombinationError(presence, count) {
   return new Error(
     `Invalid multiplicity combination: presence=${presence}, count=${count}. ` +

package/src/rdf/gloss-partitive-member.js

@@ -21,7 +21,7 @@
 
 import { PRED } from './predicates.js';
 import { namedNode, literal, quad } from './terms.js';
-import { multiplicityFromPair } from '../models/multiplicity.js';
+import { resolveMultiplicity } from '../models/multiplicity.js';
 
 // SKOS taxonomy namespaces (concept-model will ship these taxonomies).
 // Until then, the URIs are forward-compatible and resolve once the
@@ -46,16 +46,15 @@ export function* partitiveMemberToQuads(member, { memberUri }) {
     );
   }
   // Derived multiplicity URI for v3 RDF consumer backward compat.
-  // v4 PartitiveMember no longer exposes .multiplicity — compute from
-  // presence + count via multiplicityFromPair. Accept raw JSON that
-  // still carries a literal multiplicity field for pre-v4 data.
-  let mult = null;
-  if (member?.presence && member?.count) {
-    try { mult = multiplicityFromPair(member.presence, member.count); }
-    catch { /* invalid combination — skip derived emission */ }
-  } else if (typeof member?.multiplicity === 'string') {
-    mult = member.multiplicity;
-  }
+  // v4 PartitiveMember carries presence + count natively; the legacy
+  // multiplicity name is derived via the SSOT resolveMultiplicity().
+  // For raw pre-v4 JSON that bypassed the model constructor and still
+  // carries a literal multiplicity field, the resolver falls back to
+  // that field. The invalid (optional, at_least_one) combination is
+  // rejected at model construction — if it reaches the throw here,
+  // the caller bypassed the model and we want the error to surface
+  // rather than silently producing wrong RDF.
+  const mult = resolveMultiplicity(member);
   if (mult) {
     yield quad(
       namedNode(memberUri),