@treeviz/gedcom-parser 2.0.8 → 2.0.9

package/dist/constants/index.js

@@ -217,6 +217,135 @@ var profilePictureCache = (gedcom, key, value) => {
   const cached = caches.profilePictureCache?.[fullKey];
   return cached;
 };
+var isNonBiologicalPath = (path) => path.some(
+  (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
+);
+var invertHop = (kinship) => {
+  if (kinship === "parent") {
+    return "child";
+  }
+  if (kinship === "child") {
+    return "parent";
+  }
+  return kinship;
+};
+var hopRelation = (from, toIndi, kinship, inherited) => {
+  if (kinship === "parent" || kinship === "child") {
+    const parent = kinship === "parent" ? toIndi : from.indi;
+    const child = kinship === "parent" ? from.indi : toIndi;
+    const currentRelation = child.getParentType(parent);
+    if (currentRelation && currentRelation !== "biological" /* BIOLOGICAL */) {
+      return currentRelation;
+    }
+  }
+  if (inherited && inherited !== "biological" /* BIOLOGICAL */) {
+    return inherited;
+  }
+  return void 0;
+};
+var rebuildPathFromHops = (hops, skipRelation = false) => {
+  if (hops.length === 0) {
+    return [];
+  }
+  const path = [
+    {
+      indi: hops[0].indi,
+      kinship: "self",
+      level: 0,
+      levelUp: 0,
+      levelDown: 0,
+      degree: 0
+    }
+  ];
+  for (let i = 1; i < hops.length; i++) {
+    const prev = path[i - 1];
+    const { indi, kinship } = hops[i];
+    const relation = skipRelation ? void 0 : hopRelation(prev, indi, kinship, prev.relation);
+    if (kinship === "parent") {
+      path.push({
+        indi,
+        kinship,
+        relation,
+        level: prev.level + 1,
+        levelUp: prev.levelUp + 1,
+        levelDown: prev.levelDown,
+        degree: prev.degree
+      });
+      continue;
+    }
+    if (kinship === "child") {
+      path.push({
+        indi,
+        kinship,
+        relation,
+        level: prev.level - 1,
+        levelUp: prev.levelUp,
+        levelDown: prev.levelDown + 1,
+        degree: prev.levelUp ? prev.level > 0 ? prev.levelUp - prev.level + 1 : prev.levelDown - Math.abs(prev.level) : 0
+      });
+      continue;
+    }
+    path.push({
+      indi,
+      kinship,
+      relation,
+      level: prev.level,
+      levelUp: prev.levelUp,
+      levelDown: prev.levelDown,
+      degree: prev.degree
+    });
+  }
+  return path;
+};
+var storePathIfBetter = (gedcom, fromId, toId, path) => {
+  const key = `${fromId}|${toId}`;
+  const existing = pathCache(gedcom, key);
+  if (existing && (!isNonBiologicalPath(existing) || isNonBiologicalPath(path))) {
+    return;
+  }
+  pathCache(gedcom, key, path);
+};
+var cacheDiscoveredPath = (gedcom, path) => {
+  const n = path.length;
+  if (n < 2) {
+    return;
+  }
+  for (let i = 0; i < n; i++) {
+    const fromId = path[i].indi.id;
+    if (!fromId) {
+      continue;
+    }
+    for (let j = i + 1; j < n; j++) {
+      const toId = path[j].indi.id;
+      if (!toId) {
+        continue;
+      }
+      const isOriginalPair = i === 0 && j === n - 1;
+      const isDirectHop = j === i + 1;
+      const slice = path.slice(i, j + 1);
+      const sliceMixed = isNonBiologicalPath(slice);
+      if (!isOriginalPair && !isDirectHop && sliceMixed) {
+        continue;
+      }
+      const forward = i === 0 ? slice : rebuildPathFromHops(slice, !sliceMixed);
+      const reverseHops = [
+        {
+          indi: slice[slice.length - 1].indi,
+          kinship: "self"
+        }
+      ];
+      for (let k = slice.length - 2; k >= 0; k--) {
+        reverseHops.push({
+          indi: slice[k].indi,
+          kinship: invertHop(slice[k + 1].kinship)
+        });
+      }
+      const reverse = rebuildPathFromHops(reverseHops, !sliceMixed);
+      storePathIfBetter(gedcom, fromId, toId, forward);
+      storePathIfBetter(gedcom, toId, fromId, reverse);
+    }
+  }
+};
 
 // src/utils/get-all-prop.ts
 var getAllProp = (indi, prop) => {
@@ -3478,7 +3607,6 @@ var Indi = class extends Common {
     if (cache) {
       return cache;
     }
-    const visited = new Individuals().append(this);
     const mainItem = {
       indi: this,
       level: 0,
@@ -3487,129 +3615,155 @@ var Indi = class extends Common {
       degree: 0,
       kinship: "self"
     };
-    const path = [mainItem];
+    const mainPath = [mainItem];
     if (this.id === usedIndi.id) {
-      return path;
+      return mainPath;
     }
-    const queue = [
-      {
-        ...mainItem,
-        path
-      }
-    ];
-    let helper = 0;
-    while (queue.length > 0) {
-      if (helper++ > 1e6) {
-        break;
-      }
-      const {
-        indi,
-        path: path2,
-        kinship,
-        relation,
-        level,
-        levelUp,
-        levelDown,
-        degree,
-        breakOnNext,
-        breakAfterNext,
-        inLaw
-      } = queue.shift();
-      if (usedIndi.id === indi.id) {
-        if (breakOnNext) {
-          return void 0;
+    const bfs = (biologicalOnly) => {
+      const visited = new Individuals().append(this);
+      const queue = [
+        {
+          ...mainItem,
+          path: mainPath
         }
-        pathCache(this._gedcom, cacheKey, path2);
-        return path2;
-      }
-      visited.append(indi);
-      const additional = {};
-      if (breakOnNext || breakAfterNext) {
-        additional.breakOnNext = breakOnNext || breakAfterNext;
-      }
-      if (inLaw) {
-        additional.inLaw = inLaw;
-      }
-      if (kinship === "spouse" && breakAfterSpouse) {
-        if (path2.length <= 2) {
-          additional.inLaw = true;
-        } else {
-          additional.breakOnNext = true;
+      ];
+      let helper = 0;
+      while (queue.length > 0) {
+        if (helper++ > 1e6) {
+          break;
         }
-      }
-      if (kinship !== "child" || !breakAfterSpouse) {
-        indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+        const {
+          indi,
+          path,
+          kinship,
+          relation,
+          level,
+          levelUp,
+          levelDown,
+          degree,
+          breakOnNext,
+          breakAfterNext,
+          inLaw
+        } = queue.shift();
+        if (usedIndi.id === indi.id) {
+          if (breakOnNext) {
+            return void 0;
+          }
+          return path;
+        }
+        visited.append(indi);
+        const additional = {};
+        if (breakOnNext || breakAfterNext) {
+          additional.breakOnNext = breakOnNext || breakAfterNext;
+        }
+        if (inLaw) {
+          additional.inLaw = inLaw;
+        }
+        if (!biologicalOnly && kinship === "spouse" && breakAfterSpouse) {
+          if (path.length <= 2) {
+            additional.inLaw = true;
+          } else {
+            additional.breakOnNext = true;
+          }
+        }
+        if (kinship !== "child" || !breakAfterSpouse) {
+          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+            if (!visited.has(relative)) {
+              const currentRelation = indi.getParentType(relative);
+              const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
+              if (biologicalOnly && isNonBiological) {
+                return;
+              }
+              if (!biologicalOnly && breakAfterNonBiological && isNonBiological) {
+                additional.breakAfterNext = true;
+              }
+              const newItem = {
+                indi: relative,
+                kinship: "parent",
+                relation: isNonBiological ? currentRelation : relation,
+                level: level + 1,
+                levelUp: levelUp + 1,
+                levelDown,
+                degree,
+                ...additional
+              };
+              queue.push({
+                ...newItem,
+                path: [...path, newItem]
+              });
+            }
+          });
+        }
+        indi.getChildren().forEach((relative) => {
           if (!visited.has(relative)) {
-            const currentRelation = indi.getParentType(relative);
-            if (breakAfterNonBiological && currentRelation !== "biological" /* BIOLOGICAL */) {
+            const currentRelation = relative.getParentType(indi);
+            const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
+            if (biologicalOnly && isNonBiological) {
+              return;
+            }
+            if (!biologicalOnly && breakAfterNonBiological && isNonBiological) {
               additional.breakAfterNext = true;
             }
             const newItem = {
               indi: relative,
-              kinship: "parent",
-              relation: currentRelation && currentRelation !== "biological" /* BIOLOGICAL */ ? currentRelation : relation,
-              level: level + 1,
-              levelUp: levelUp + 1,
-              levelDown,
-              degree,
+              kinship: "child",
+              relation: isNonBiological ? currentRelation : relation,
+              level: level - 1,
+              levelUp,
+              levelDown: levelDown + 1,
+              degree: levelUp ? level > 0 ? levelUp - level + 1 : levelDown - Math.abs(level) : 0,
               ...additional
             };
             queue.push({
               ...newItem,
-              path: [...path2, newItem]
+              path: [...path, newItem]
             });
           }
         });
-      }
-      indi.getChildren().forEach((relative) => {
-        if (!visited.has(relative)) {
-          const currentRelation = relative.getParentType(indi);
-          if (breakAfterNonBiological && currentRelation !== "biological" /* BIOLOGICAL */) {
-            additional.breakAfterNext = true;
-          }
-          const newItem = {
-            indi: relative,
-            kinship: "child",
-            relation: currentRelation && currentRelation !== "biological" /* BIOLOGICAL */ ? currentRelation : relation,
-            level: level - 1,
-            levelUp,
-            levelDown: levelDown + 1,
-            degree: levelUp ? level > 0 ? levelUp - level + 1 : levelDown - Math.abs(level) : 0,
-            ...additional
-          };
-          queue.push({
-            ...newItem,
-            path: [...path2, newItem]
-          });
+        if (biologicalOnly) {
+          continue;
         }
-      });
-      indi.getCoParents().forEach((relative) => {
-        if (!visited.has(relative)) {
-          const currentAddition = {};
-          if (relation && relation !== "biological" /* BIOLOGICAL */) {
-            currentAddition.relation = relation;
-          }
-          if (inLaw) {
-            currentAddition.breakOnNext = true;
+        indi.getCoParents().forEach((relative) => {
+          if (!visited.has(relative)) {
+            const currentAddition = {};
+            if (relation && relation !== "biological" /* BIOLOGICAL */) {
+              currentAddition.relation = relation;
+            }
+            if (inLaw) {
+              currentAddition.breakOnNext = true;
+            }
+            const newItem = {
+              indi: relative,
+              kinship: "spouse",
+              level,
+              levelUp,
+              levelDown,
+              degree,
+              ...additional,
+              ...currentAddition
+            };
+            queue.push({
+              ...newItem,
+              path: [...path, newItem]
+            });
           }
-          const newItem = {
-            indi: relative,
-            kinship: "spouse",
-            level,
-            levelUp,
-            levelDown,
-            degree,
-            ...additional,
-            ...currentAddition
-          };
-          queue.push({
-            ...newItem,
-            path: [...path2, newItem]
-          });
-        }
-      });
+        });
+      }
+      return void 0;
+    };
+    const foundPath = bfs(false);
+    const lastItem = foundPath?.[foundPath.length - 1];
+    if (lastItem?.relation && lastItem.relation !== "biological" /* BIOLOGICAL */) {
+      const biologicalPath = bfs(true);
+      if (biologicalPath) {
+        cacheDiscoveredPath(this._gedcom, biologicalPath);
+        return biologicalPath;
+      }
     }
-    return void 0;
+    if (foundPath) {
+      cacheDiscoveredPath(this._gedcom, foundPath);
+    }
+    return foundPath;
   }
   kinship(other, showMainPerson, lang = "en", entirePath, displayName = "givenname") {
     const KinshipTranslatorClass2 = getKinshipTranslatorClass();
@@ -4581,6 +4735,44 @@ var KinshipTranslatorBasic = class {
     }
     return this.pathN?.indi;
   }
+  /**
+   * True when the path goes through a common ancestor whose two children
+   * (the person we came from and the person we go to) share fewer than two
+   * biological parents — i.e. they are half-siblings, so every collateral
+   * relative on this path is a half-aunt/half-cousin/... too.
+   *
+   * Direct ancestors/descendants and paths that already use a
+   * step/adopted/foster edge are never half-blood.
+   */
+  get isHalfBlood() {
+    const path = this.path;
+    if (!path || path.length < 3) {
+      return false;
+    }
+    if (path.some(
+      (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
+    )) {
+      return false;
+    }
+    let peakIndex = -1;
+    for (let i = 1; i < path.length; i++) {
+      if (path[i].kinship === "parent") {
+        peakIndex = i;
+      }
+    }
+    if (peakIndex <= 0 || peakIndex >= path.length - 1) {
+      return false;
+    }
+    if (path[peakIndex + 1].kinship !== "child") {
+      return false;
+    }
+    const siblingA = path[peakIndex - 1].indi;
+    const siblingB = path[peakIndex + 1].indi;
+    const parentsA = siblingA.getBiologicalParents();
+    const parentsB = siblingB.getBiologicalParents();
+    const inter = parentsA.intersection(parentsB);
+    return inter.length === 1 && (parentsA.length > 1 || parentsB.length > 1);
+  }
   indirect() {
     return "";
   }
@@ -4608,6 +4800,9 @@ var KinshipTranslatorBasic = class {
   relationType(relation) {
     return relation ?? "";
   }
+  halfBlood(relation) {
+    return relation ?? "";
+  }
   of(relation) {
     return relation ?? "";
   }
@@ -4846,14 +5041,34 @@ var KinshipTranslatorHU = class extends KinshipTranslatorBasic {
     return `${prefix.replace(/nagy$/, "")}unoka`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    if (!inter || inter.length < 2) {
-      return "f\xE9ltestv\xE9r";
-    }
     return "testv\xE9r";
   }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    const [head, ...rest] = relation.split(" ");
+    if (!head) {
+      return relation;
+    }
+    const prefixed = this.prefixHalf(head);
+    return [prefixed, ...rest].join(" ");
+  }
+  /**
+   * AkH. 139: compounds of more than two members stay closed up to 6
+   * syllables; longer ones are hyphenated at the main boundary. A head
+   * that is already hyphenated also takes a hyphenated half- prefix.
+   */
+  prefixHalf(head) {
+    if (head.includes("-") || !/[aáeéiíoóöőuúüű]/i.test(head)) {
+      return `f\xE9l-${head}`;
+    }
+    const syllables = (head.match(/[aáeéiíoóöőuúüű]/gi) ?? []).length + 1;
+    if (syllables > 6) {
+      return `f\xE9l-${head}`;
+    }
+    return `f\xE9l${head}`;
+  }
   spouse() {
     if (this.personN?.isMale()) {
       return "f\xE9rj";
@@ -5052,20 +5267,22 @@ var KinshipTranslatorEn = class extends KinshipTranslatorBasic {
     return `${prefix}child`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "half-";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}brother`;
+      return "brother";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}sister`;
+      return "sister";
+    }
+    return "sibling";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (relation.includes(" ")) {
+      return `half ${relation}`;
     }
-    return `${prefix}sibling`;
+    return `half-${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5247,20 +5464,22 @@ var KinshipTranslatorDe = class extends KinshipTranslatorBasic {
     return `${prefix}kind`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "Halb";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}bruder`;
+      return "bruder";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}schwester`;
+      return "schwester";
+    }
+    return "geschwister";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (/^[A-ZÄÖÜ]/.test(relation) || /[-\s]/.test(relation)) {
+      return `Halb-${relation}`;
     }
-    return `${prefix}geschwister`;
+    return `Halb${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5442,20 +5661,19 @@ var KinshipTranslatorFr = class extends KinshipTranslatorBasic {
     return `${prefix}enfant`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "demi-";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}fr\xE8re`;
+      return "fr\xE8re";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}s\u0153ur`;
+      return "s\u0153ur";
     }
-    return `${prefix}fr\xE8re/s\u0153ur`;
+    return "fr\xE8re/s\u0153ur";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    return `demi-${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5552,12 +5770,12 @@ var InLawsEs = {
   "madre del (c\xF3nyuge|esposa|esposo)": "suegra",
   "padre del (c\xF3nyuge|esposa|esposo)": "suegro",
   "padre/madre del (c\xF3nyuge|esposa|esposo)": "suegro/suegra",
-  "esposa de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ada",
-  "esposo de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ado",
-  "c\xF3nyuge de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ado/cu\xF1ada",
-  "(medio )?hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ada",
-  "(medio )?hermano del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado",
-  "(medio )?hermano/hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado/cu\xF1ada"
+  "esposa de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ada",
+  "esposo de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ado",
+  "c\xF3nyuge de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ado/cu\xF1ada",
+  "(medio |media |medio/a )?hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ada",
+  "(medio |media |medio/a )?hermano del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado",
+  "(medio |media |medio/a )?hermano/hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado/cu\xF1ada"
 };
 
 // src/kinship-translator/kinship-translator.es.ts
@@ -5637,20 +5855,25 @@ var KinshipTranslatorEs = class extends KinshipTranslatorBasic {
     return `${prefix}hijo/hija`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "medio ";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}hermano`;
+      return "hermano";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}hermana`;
+      return "hermana";
+    }
+    return "hermano/hermana";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (this.personN?.isFemale()) {
+      return `media ${relation}`;
+    }
+    if (this.personN?.isMale()) {
+      return `medio ${relation}`;
     }
-    return `${prefix}hermano/hermana`;
+    return `medio/a ${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5832,6 +6055,7 @@ var KinshipTranslator = class {
     } else if (personN.level !== 0) {
       relation = this.removal();
     }
+    relation = this.translator?.halfBlood(relation);
     relation = this.translator?.relationType(relation);
     if (this.translator?.isOfSpouse) {
       relation = this.translator?.ofSpouse(relation);