@diagrammo/dgmo 0.48.2 → 0.49.0

package/dist/chunk-IAEC4KLA.js

@@ -0,0 +1,492 @@
+import {
+  familyCardRows
+} from "./chunk-IVKC4GID.js";
+import {
+  HEADER_HEIGHT,
+  LABEL_FONT_SIZE,
+  META_FONT_SIZE,
+  META_LINE_HEIGHT,
+  SEPARATOR_GAP
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  measureText
+} from "./chunk-5LWQH6QV.js";
+import {
+  buildCoupleQuotient,
+  rankClasses
+} from "./chunk-QQJUTGQH.js";
+
+// src/family/layout.ts
+var MARGIN = 30;
+var MIN_CARD_W = 132;
+var CARD_H_PAD = 12;
+var CARD_TEXT_PAD = 12;
+var H_GAP = 60;
+var ROW_GAP = 74;
+var KEY_VALUE_GAP = 6;
+var KEY_X = 10;
+var GUTTER_WIDTH = 72;
+function birthYear(persons, id) {
+  const b = persons.get(id)?.metadata["b"];
+  if (b === void 0) return null;
+  const n = parseInt(b, 10);
+  return Number.isFinite(n) ? n : null;
+}
+function sortChildrenByBirth(children, persons) {
+  return children.map((c, i) => ({ c, i, b: birthYear(persons, c.personId) })).sort((x, y) => {
+    if (x.b !== null && y.b !== null) return x.b - y.b || x.i - y.i;
+    if (x.b !== null) return -1;
+    if (y.b !== null) return 1;
+    return x.i - y.i;
+  }).map((o) => o.c);
+}
+function computeBloodline(unions, focusId) {
+  const childOf = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  const unionById = new Map(unions.map((u) => [u.id, u]));
+  for (const u of unions) {
+    for (const p of u.parents)
+      (parentOf.get(p) ?? parentOf.set(p, []).get(p)).push(u.id);
+    for (const c of u.children)
+      (childOf.get(c.personId) ?? childOf.set(c.personId, []).get(c.personId)).push(u.id);
+  }
+  const set = /* @__PURE__ */ new Set([focusId]);
+  const up = [focusId];
+  while (up.length) {
+    const id = up.pop();
+    for (const uid of childOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents)
+        if (!set.has(p)) {
+          set.add(p);
+          up.push(p);
+        }
+  }
+  const down = [focusId];
+  while (down.length) {
+    const id = down.pop();
+    for (const uid of parentOf.get(id) ?? [])
+      for (const c of unionById.get(uid).children)
+        if (!set.has(c.personId)) {
+          set.add(c.personId);
+          down.push(c.personId);
+        }
+  }
+  for (const id of [...set])
+    for (const uid of parentOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents) set.add(p);
+  return set;
+}
+function cardSize(p) {
+  const rows = familyCardRows(p);
+  const labeled = rows.filter((r) => !r.year);
+  const maxKeyW = labeled.length ? Math.max(...labeled.map((r) => measureText(`${r.key}: `, META_FONT_SIZE))) : 0;
+  const valueX = KEY_X + maxKeyW + KEY_VALUE_GAP;
+  let contentRight = 0;
+  for (const r of rows) {
+    const right = r.year ? KEY_X + measureText(r.value, META_FONT_SIZE) : valueX + measureText(r.value, META_FONT_SIZE);
+    contentRight = Math.max(contentRight, right);
+  }
+  const labelW = measureText(p.label, LABEL_FONT_SIZE);
+  const width = Math.max(
+    MIN_CARD_W,
+    labelW + CARD_TEXT_PAD * 2,
+    contentRight + CARD_TEXT_PAD
+  );
+  const height = rows.length > 0 ? HEADER_HEIGHT + SEPARATOR_GAP + rows.length * META_LINE_HEIGHT + CARD_H_PAD : HEADER_HEIGHT + CARD_H_PAD;
+  return { width, height };
+}
+function orderRow(persons, parentUnions, unionParents, unionChildren, unionOrder) {
+  const disco = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const visit = (id) => {
+    if (disco.has(id)) return;
+    disco.set(id, seq++);
+    for (const uid of parentUnions.get(id) ?? []) {
+      for (const sp of unionParents.get(uid) ?? []) visit(sp);
+      for (const ch of unionChildren.get(uid) ?? []) visit(ch);
+    }
+  };
+  for (const uid of unionOrder) {
+    for (const p of unionParents.get(uid) ?? []) visit(p);
+  }
+  for (const id of persons.keys()) visit(id);
+  return disco;
+}
+function orderRowSpouses(ids, spouseAdj, discoOf) {
+  const inRow = new Set(ids);
+  const nbrs = (id) => [...spouseAdj.get(id) ?? []].filter((n) => inRow.has(n));
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const seed of [...ids].sort((a, b) => discoOf(a) - discoOf(b))) {
+    if (visited.has(seed)) continue;
+    const comp = [];
+    const stack = [seed];
+    visited.add(seed);
+    while (stack.length) {
+      const v = stack.pop();
+      comp.push(v);
+      for (const w of nbrs(v))
+        if (!visited.has(w)) {
+          visited.add(w);
+          stack.push(w);
+        }
+    }
+    if (comp.length === 1) {
+      components.push(comp);
+      continue;
+    }
+    const start = comp.filter((id) => nbrs(id).length <= 1).sort((a, b) => discoOf(a) - discoOf(b))[0] ?? comp.slice().sort((a, b) => discoOf(a) - discoOf(b))[0];
+    const path = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cur = start;
+    while (cur !== void 0 && !seen.has(cur)) {
+      seen.add(cur);
+      path.push(cur);
+      cur = nbrs(cur).filter((n) => !seen.has(n)).sort((a, b) => discoOf(a) - discoOf(b))[0];
+    }
+    for (const id of comp) if (!seen.has(id)) path.push(id);
+    components.push(path);
+  }
+  components.sort(
+    (x, y) => Math.min(...x.map(discoOf)) - Math.min(...y.map(discoOf))
+  );
+  return components.flat();
+}
+function focusFamily(parsed, focusId) {
+  if (!parsed.persons.has(focusId)) {
+    return { persons: parsed.persons, unions: parsed.unions, parents: [] };
+  }
+  const childOf = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  const unionById = new Map(parsed.unions.map((u) => [u.id, u]));
+  for (const u of parsed.unions) {
+    for (const p of u.parents)
+      (parentOf.get(p) ?? parentOf.set(p, []).get(p)).push(u.id);
+    for (const c of u.children)
+      (childOf.get(c.personId) ?? childOf.set(c.personId, []).get(c.personId)).push(u.id);
+  }
+  const visible = /* @__PURE__ */ new Set([focusId]);
+  const down = [focusId];
+  while (down.length) {
+    const id = down.pop();
+    for (const uid of parentOf.get(id) ?? [])
+      for (const c of unionById.get(uid).children)
+        if (!visible.has(c.personId)) {
+          visible.add(c.personId);
+          down.push(c.personId);
+        }
+  }
+  for (const id of [...visible])
+    for (const uid of parentOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents) visible.add(p);
+  const parentIds = /* @__PURE__ */ new Set();
+  for (const uid of childOf.get(focusId) ?? [])
+    for (const p of unionById.get(uid).parents) parentIds.add(p);
+  const parents = [...parentIds].map((id) => parsed.persons.get(id)).filter((p) => p !== void 0);
+  const persons = /* @__PURE__ */ new Map();
+  for (const [id, p] of parsed.persons) if (visible.has(id)) persons.set(id, p);
+  const unions = parsed.unions.filter((u) => u.parents.every((p) => visible.has(p))).map((u) => ({
+    ...u,
+    children: u.children.filter((c) => visible.has(c.personId))
+  }));
+  return { persons, unions, parents };
+}
+function layoutFamily(parsed, focusId) {
+  const focused = focusId ? focusFamily(parsed, focusId) : null;
+  const persons = focused ? focused.persons : parsed.persons;
+  const unions = (focused ? focused.unions : parsed.unions).map((u) => ({ ...u, children: sortChildrenByBirth(u.children, persons) }));
+  const focusParents = focused ? focused.parents : [];
+  const highlightId = parsed.options["highlight"] || null;
+  const litSet = highlightId ? computeBloodline(unions, highlightId) : null;
+  const showGen = parsed.options["generations"] === "true";
+  const ANCESTOR_STAGGER = 20;
+  const ANCESTOR_BAND = focusParents.length > 0 ? 34 + Math.max(0, focusParents.length - 1) * ANCESTOR_STAGGER : 0;
+  const quotient = buildCoupleQuotient(persons, unions);
+  const classRow = quotient.cycle ? /* @__PURE__ */ new Map() : rankClasses(quotient);
+  const rowOf = (id) => {
+    const c = quotient.classOf.get(id);
+    return c === void 0 ? 0 : classRow.get(c) ?? 0;
+  };
+  const parentUnions = /* @__PURE__ */ new Map();
+  const unionParents = /* @__PURE__ */ new Map();
+  const unionChildren = /* @__PURE__ */ new Map();
+  const unionOrder = [];
+  for (const u of unions) {
+    unionOrder.push(u.id);
+    unionParents.set(u.id, [...u.parents]);
+    unionChildren.set(
+      u.id,
+      u.children.map((c) => c.personId)
+    );
+    for (const p of u.parents) {
+      (parentUnions.get(p) ?? parentUnions.set(p, []).get(p)).push(u.id);
+    }
+  }
+  const disco = orderRow(
+    persons,
+    parentUnions,
+    unionParents,
+    unionChildren,
+    unionOrder
+  );
+  const sizes = /* @__PURE__ */ new Map();
+  for (const [id, p] of persons) sizes.set(id, cardSize(p));
+  const rowPersons = /* @__PURE__ */ new Map();
+  let maxRow = 0;
+  for (const id of persons.keys()) {
+    const r = rowOf(id);
+    maxRow = Math.max(maxRow, r);
+    (rowPersons.get(r) ?? rowPersons.set(r, []).get(r)).push(id);
+  }
+  const spouseAdj = /* @__PURE__ */ new Map();
+  for (const u of unions) {
+    if (u.parents.length !== 2) continue;
+    const [a, b] = u.parents;
+    (spouseAdj.get(a) ?? spouseAdj.set(a, /* @__PURE__ */ new Set()).get(a)).add(b);
+    (spouseAdj.get(b) ?? spouseAdj.set(b, /* @__PURE__ */ new Set()).get(b)).add(a);
+  }
+  const discoOf = (id) => disco.get(id) ?? 0;
+  for (const [r, arr] of rowPersons) {
+    rowPersons.set(r, orderRowSpouses(arr, spouseAdj, discoOf));
+  }
+  const rowHeight = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    let h = 0;
+    for (const id of rowPersons.get(r) ?? [])
+      h = Math.max(h, sizes.get(id).height);
+    rowHeight.set(r, h);
+  }
+  const rowY = /* @__PURE__ */ new Map();
+  {
+    let acc = MARGIN + ANCESTOR_BAND;
+    for (let r = 0; r <= maxRow; r++) {
+      rowY.set(r, acc);
+      acc += (rowHeight.get(r) ?? 0) + ROW_GAP;
+    }
+  }
+  const centerX = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    let acc = 0;
+    for (const id of rowPersons.get(r) ?? []) {
+      const w = sizes.get(id).width;
+      centerX.set(id, acc + w / 2);
+      acc += w + H_GAP;
+    }
+  }
+  const resolveRow = (ids, desired) => {
+    let prevRight = -Infinity;
+    for (const id of ids) {
+      const half = sizes.get(id).width / 2;
+      let c = desired.get(id) ?? centerX.get(id);
+      const minC = prevRight + H_GAP + half;
+      if (c < minC) c = minC;
+      centerX.set(id, c);
+      prevRight = c + half;
+    }
+  };
+  const childrenBlockCenter = (uid) => {
+    const cs = (unionChildren.get(uid) ?? []).filter((c) => centerX.has(c)).map((c) => centerX.get(c));
+    if (cs.length === 0) return void 0;
+    return (Math.min(...cs) + Math.max(...cs)) / 2;
+  };
+  const rowOfPerson = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++)
+    for (const id of rowPersons.get(r) ?? []) rowOfPerson.set(id, r);
+  for (let iter = 0; iter < 4; iter++) {
+    for (let r = maxRow - 1; r >= 0; r--) {
+      const desiredParts = /* @__PURE__ */ new Map();
+      const add = (id, x) => {
+        (desiredParts.get(id) ?? desiredParts.set(id, []).get(id)).push(x);
+      };
+      for (const u of unions) {
+        const onRow = u.parents.filter((p) => rowOfPerson.get(p) === r);
+        if (onRow.length === 0) continue;
+        const cc = childrenBlockCenter(u.id);
+        if (cc === void 0) continue;
+        if (onRow.length === 2) {
+          const lr = [...onRow].sort(
+            (a, b) => centerX.get(a) - centerX.get(b)
+          );
+          const [l, rr] = lr;
+          const d = sizes.get(l).width / 2 + H_GAP + sizes.get(rr).width / 2;
+          add(l, cc - d / 2);
+          add(rr, cc + d / 2);
+        } else {
+          for (const p of onRow) add(p, cc);
+        }
+      }
+      const desired = /* @__PURE__ */ new Map();
+      for (const [id, xs] of desiredParts)
+        desired.set(id, xs.reduce((a, b) => a + b, 0) / xs.length);
+      resolveRow(rowPersons.get(r) ?? [], desired);
+    }
+  }
+  const unionMid = (u) => {
+    const ps = u.parents.filter((p) => centerX.has(p));
+    return ps.reduce((s, p) => s + centerX.get(p), 0) / ps.length;
+  };
+  for (let pass = 0; pass < 2; pass++) {
+    for (let r = 1; r <= maxRow; r++) {
+      const desired = /* @__PURE__ */ new Map();
+      for (const u of unions) {
+        const kids = u.children.map((c) => c.personId).filter((id) => rowOfPerson.get(id) === r && centerX.has(id)).sort((a, b) => centerX.get(a) - centerX.get(b));
+        if (kids.length === 0 || u.parents.every((p) => !centerX.has(p)))
+          continue;
+        const blockW = kids.reduce((s, id) => s + sizes.get(id).width, 0) + H_GAP * (kids.length - 1);
+        let left = unionMid(u) - blockW / 2;
+        for (const id of kids) {
+          const w = sizes.get(id).width;
+          desired.set(id, left + w / 2);
+          left += w + H_GAP;
+        }
+      }
+      resolveRow(rowPersons.get(r) ?? [], desired);
+    }
+  }
+  let minLeft = Infinity;
+  for (const id of persons.keys())
+    minLeft = Math.min(minLeft, centerX.get(id) - sizes.get(id).width / 2);
+  const gutter = showGen ? GUTTER_WIDTH : 0;
+  const dx = (Number.isFinite(minLeft) ? MARGIN - minLeft : MARGIN) + gutter;
+  const nodes = [];
+  const topY = /* @__PURE__ */ new Map();
+  const bottomY = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    for (const id of rowPersons.get(r) ?? []) {
+      const p = persons.get(id);
+      const s = sizes.get(id);
+      const x = centerX.get(id) - s.width / 2 + dx;
+      const y = rowY.get(r);
+      centerX.set(id, x + s.width / 2);
+      topY.set(id, y);
+      bottomY.set(id, y + s.height);
+      nodes.push({
+        id: p.id,
+        label: p.label,
+        sex: p.sex,
+        metadata: p.metadata,
+        ...p.color !== void 0 && { color: p.color },
+        tagMetadata: p.tagMetadata,
+        x,
+        y,
+        width: s.width,
+        height: s.height,
+        row: r,
+        ...p.placeholder && { placeholder: true },
+        ...litSet && !litSet.has(id) && { dimmed: true },
+        lineNumber: p.lineNumber
+      });
+    }
+  }
+  let contentRightEdge = 0;
+  for (const n of nodes)
+    contentRightEdge = Math.max(contentRightEdge, n.x + n.width);
+  const bars = [];
+  for (const u of unions) {
+    if (u.parents.length !== 2) continue;
+    const [a, b] = u.parents;
+    if (!centerX.has(a) || !centerX.has(b)) continue;
+    const rowTop = Math.min(topY.get(a), topY.get(b));
+    const ay = rowTop + HEADER_HEIGHT / 2;
+    const ax = centerX.get(a);
+    const bx = centerX.get(b);
+    const x1 = Math.min(ax, bx);
+    const x2 = Math.max(ax, bx);
+    const leftId = ax <= bx ? a : b;
+    const rightId = ax <= bx ? b : a;
+    const gapCenter = (centerX.get(leftId) + sizes.get(leftId).width / 2 + (centerX.get(rightId) - sizes.get(rightId).width / 2)) / 2;
+    bars.push({
+      unionId: u.id,
+      x1,
+      x2,
+      y: ay,
+      midX: (x1 + x2) / 2,
+      labelX: gapCenter,
+      ...u.metadata["m"] !== void 0 && { year: u.metadata["m"] },
+      ...u.divorced && { divorced: true },
+      ...litSet && !(litSet.has(a) && litSet.has(b)) && { dimmed: true },
+      lineNumber: u.lineNumber
+    });
+  }
+  const barByUnion = new Map(bars.map((bar) => [bar.unionId, bar]));
+  const edges = [];
+  for (const u of unions) {
+    if (u.children.length === 0) continue;
+    let anchorX;
+    let anchorY;
+    const bar = barByUnion.get(u.id);
+    if (bar) {
+      anchorX = bar.midX;
+      anchorY = bar.y;
+    } else {
+      const p = u.parents[0];
+      if (p === void 0 || !centerX.has(p)) continue;
+      anchorX = centerX.get(p);
+      anchorY = bottomY.get(p);
+    }
+    const kids = u.children.filter((c) => centerX.has(c.personId));
+    if (kids.length === 0) continue;
+    const childTop = Math.min(...kids.map((c) => topY.get(c.personId)));
+    const parentsBottom = Math.max(
+      ...u.parents.filter((p) => bottomY.has(p)).map((p) => bottomY.get(p))
+    );
+    const midY = (parentsBottom + childTop) / 2;
+    for (const c of kids) {
+      const cx = centerX.get(c.personId);
+      const cTop = topY.get(c.personId);
+      edges.push({
+        unionId: u.id,
+        childId: c.personId,
+        points: [
+          { x: anchorX, y: anchorY },
+          { x: anchorX, y: midY },
+          { x: cx, y: midY },
+          { x: cx, y: cTop }
+        ],
+        adopted: c.adopted,
+        ...litSet && !litSet.has(c.personId) && { dimmed: true }
+      });
+    }
+  }
+  const ancestors = [];
+  let focusAnchor;
+  if (focusId && focusParents.length > 0 && centerX.has(focusId)) {
+    const fx = centerX.get(focusId);
+    const fTop = topY.get(focusId);
+    focusAnchor = { x: fx, y: fTop };
+    focusParents.forEach((p, i) => {
+      ancestors.push({
+        id: p.id,
+        label: p.label,
+        sex: p.sex,
+        ...p.color !== void 0 && { color: p.color },
+        x: fx,
+        y: MARGIN + 10 + i * ANCESTOR_STAGGER
+      });
+    });
+  }
+  const width = contentRightEdge + MARGIN;
+  const lastR = maxRow;
+  const height = (rowY.get(lastR) ?? MARGIN) + (rowHeight.get(lastR) ?? 0) + MARGIN;
+  const rows = [];
+  for (let r = 0; r <= maxRow; r++) {
+    if (!rowPersons.get(r)?.length) continue;
+    rows.push({ row: r, y: rowY.get(r), height: rowHeight.get(r) ?? 0 });
+  }
+  return {
+    nodes,
+    bars,
+    edges,
+    ancestors,
+    ...focusAnchor !== void 0 && { focusAnchor },
+    rows,
+    width,
+    height
+  };
+}
+
+export {
+  focusFamily,
+  layoutFamily
+};
+//# sourceMappingURL=chunk-IAEC4KLA.js.map

package/dist/{chunk-J5FIXQRT.js → chunk-IBC35BTK.js}

@@ -11,15 +11,15 @@ import {
   LEGEND_PILL_FONT_SIZE,
   LEGEND_PILL_PAD,
   measureLegendText
-} from "./chunk-QOOUC2J5.js";
+} from "./chunk-HQCHYB5F.js";
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   injectDefaultTagMetadata,
   resolveTagColor,
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-HBVD67XG.js";
 
 // src/org/layout.ts
 import { hierarchy, tree } from "d3-hierarchy";
@@ -810,4 +810,4 @@ function layoutOrg(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, expan
 export {
   layoutOrg
 };
-//# sourceMappingURL=chunk-J5FIXQRT.js.map
+//# sourceMappingURL=chunk-IBC35BTK.js.map

package/dist/{chunk-NURGB5Z4.js → chunk-IFK3GIUW.js}

@@ -5,7 +5,7 @@ import {
   parseFirstLine,
   splitNameAndMeta,
   warnUnknownMetaKeys
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-ZNQX6QWH.js";
 import {
   makeDgmoError,
   makeFail,
@@ -332,4 +332,4 @@ function assignGlobalNumbers(result) {
 export {
   parseTechRadar
 };
-//# sourceMappingURL=chunk-NURGB5Z4.js.map
+//# sourceMappingURL=chunk-IFK3GIUW.js.map

package/dist/{chunk-FANX6UJR.js → chunk-IHLSHCPZ.js}

@@ -5,7 +5,7 @@ import {
 import {
   renderCollapseBar,
   renderNodeCard
-} from "./chunk-VOKGH627.js";
+} from "./chunk-AHGF2YYA.js";
 import {
   CARD_RADIUS,
   COLLAPSE_BAR_HEIGHT,
@@ -25,16 +25,16 @@ import {
 } from "./chunk-3CIOJ5YJ.js";
 import {
   layoutOrg
-} from "./chunk-J5FIXQRT.js";
-import {
-  renderIntegratedLegend
-} from "./chunk-PWIHZ6NJ.js";
+} from "./chunk-IBC35BTK.js";
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-4UDKKGHH.js";
 import {
   getMaxLegendReservedHeight
-} from "./chunk-YAA6IID3.js";
+} from "./chunk-7UEMZREK.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT
@@ -49,13 +49,13 @@ import {
   LEGEND_EYE_SIZE,
   LEGEND_GROUP_GAP,
   LEGEND_HEIGHT
-} from "./chunk-QOOUC2J5.js";
+} from "./chunk-HQCHYB5F.js";
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   parseOrg
-} from "./chunk-RVMRZAPB.js";
+} from "./chunk-F743CM2N.js";
 import {
   contrastText,
   mix,
@@ -65,7 +65,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-HBVD67XG.js";
 
 // src/org/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -484,4 +484,4 @@ export {
   renderOrg,
   renderOrgForExport
 };
-//# sourceMappingURL=chunk-FANX6UJR.js.map
+//# sourceMappingURL=chunk-IHLSHCPZ.js.map

package/dist/{chunk-GMR5MFHJ.js → chunk-IUK7AGD4.js}

@@ -3,7 +3,7 @@ import {
   splitNameAndMeta,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-ZNQX6QWH.js";
 import {
   makeDgmoError
 } from "./chunk-CXK4DZH3.js";
@@ -336,4 +336,4 @@ export {
   parseTimelineDate,
   parseTimelineEventLine
 };
-//# sourceMappingURL=chunk-GMR5MFHJ.js.map
+//# sourceMappingURL=chunk-IUK7AGD4.js.map

package/dist/chunk-IVKC4GID.js

@@ -0,0 +1,32 @@
+// src/family/card-model.ts
+var LABELED_KEYS = [
+  ["bp", "Born"],
+  ["dp", "Died"],
+  ["occupation", "Occupation"],
+  ["military", "Military"],
+  ["education", "Education"],
+  ["religion", "Religion"],
+  ["burial", "Burial"]
+];
+function familyDisplayLabel(p) {
+  return !p.placeholder && p.metadata["d"] ? `\u2020 ${p.label}` : p.label;
+}
+function familyCardRows(p) {
+  const rows = [];
+  const b = p.metadata["b"];
+  const d = p.metadata["d"];
+  if (b && d) rows.push({ key: "", value: `${b} \u2013 ${d}`, year: true });
+  else if (b) rows.push({ key: "", value: `b. ${b}`, year: true });
+  else if (d) rows.push({ key: "", value: `d. ${d}`, year: true });
+  for (const [key, label] of LABELED_KEYS) {
+    const v = p.metadata[key];
+    if (v) rows.push({ key: label, value: v, year: false });
+  }
+  return rows;
+}
+
+export {
+  familyDisplayLabel,
+  familyCardRows
+};
+//# sourceMappingURL=chunk-IVKC4GID.js.map