{"version":3,"file":"linked_column_postfix.cjs","names":["isNil","getAxisId","readAnnotation","Annotation","canonicalizeJson"],"sources":["../../src/labels/linked_column_postfix.ts"],"sourcesContent":["/**\n * Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).\n *\n * A linked column is\n * reached by a CHAIN of linkers, and we distinguish two such columns by the same ideology the main\n * algorithm uses — \"find the minimal difference, escalate until unique\" — over two dimensions:\n *\n *   - root:    the single source axis of the chain, derived from `linkers[0]` (one of its axesSpec).\n *              This is \"the source\" — it's what we prefer to show (\"difference of sources\").\n *   - linkers: the linker chain itself (by `LinkLabel`), a per-step fallback used only where roots\n *              coincide.\n *\n * Nothing is stored redundantly: the caller passes the linker path (`linkers`) and the hit spec;\n * root and every token are computed on the fly. The caller also supplies the `stem` (label+trace+\n * quals from the existing single-entity machinery); this module only adds the path postfix, and\n * only where stems collide.\n */\nimport {\n  Annotation,\n  canonicalizeJson,\n  getAxisId,\n  readAnnotation,\n  type AxisSpec,\n  type PColumnSpec,\n} from \"@milaboratories/pl-model-common\";\nimport { isNil } from \"es-toolkit\";\n\n/**\n * One entry to label: its stem plus the linker path that reached it (`linkers[0]` source-most) and\n * the hit spec used to orient the chain. Plain columns pass neither. Entries with different markers\n * (something the UI shows beside the label) never collide.\n */\nexport type PostfixEntry = {\n  stem: string;\n  hit?: PColumnSpec;\n  linkers?: PColumnSpec[];\n  marker?: string;\n};\n\n/**\n * One distinguishing piece of the postfix: the full source spec (axis or linker column — no info\n * lost) plus `text`, the minimal text that sets it apart from the siblings (a label, or only the\n * differing domain keys). Custom formatters may use `spec` freely; `text` is the default rendering.\n */\nexport type LinkerPart<Spec> = { spec: Spec; text: string };\n\n/** The distinguishing source of one column: its root axis (when it differs) + the linker chain. */\nexport type LinkerParts = {\n  root?: LinkerPart<AxisSpec>;\n  linkers: LinkerPart<PColumnSpec>[];\n};\n\n/**\n * Renders the postfix zone from the distinguishing sources. Default:\n * `via ${[root, linkers.join(\" > \")].filter(Boolean).join(\" \")}` (using each piece's `text`).\n * Returning `undefined` — or the empty string `\"\"` — suppresses the postfix entirely (the column\n * keeps just its stem); the two are treated identically.\n */\nexport type LinkerFormatter = (\n  parts: LinkerParts,\n  hit: PColumnSpec | undefined,\n  index: number,\n) => string | undefined;\n\nfunction defaultLinkerFormatter(parts: LinkerParts): string {\n  const chain = parts.linkers.map((l) => l.text).join(\" > \");\n  const pieces = [parts.root?.text, chain || undefined].filter((p): p is string => !isNil(p));\n  return pieces.length === 0 ? \"\" : `via ${pieces.join(\" \")}`;\n}\n\ntype AxisIdentity = { label?: string } & Pick<AxisSpec, \"name\" | \"domain\" | \"contextDomain\">;\n\nfunction extractAxisIdentity(axis: AxisSpec): AxisIdentity {\n  const id = getAxisId(axis);\n  return {\n    label: readAnnotation(axis, Annotation.Label)?.trim() || undefined,\n    name: id.name,\n    domain: id.domain,\n    contextDomain: id.contextDomain,\n  };\n}\n\n/**\n * A linker is named ONLY by its human label (`LinkLabel`/`Label`) — never by its technical column\n * name. Returns `undefined` for an unlabeled linker, which callers treat as \"not renderable\": such a\n * step is skipped, and disambiguation falls to another step or the root.\n */\nfunction extractLinkerIdentity(linker: PColumnSpec): AxisIdentity | undefined {\n  const label = (\n    readAnnotation(linker, Annotation.LinkLabel) ?? readAnnotation(linker, Annotation.Label)\n  )?.trim();\n  return label ? { label, name: label } : undefined;\n}\n\n/** Domain keys where `mine` differs from at least one competitor. */\nfunction differingKeys(\n  mine: Record<string, string> | undefined,\n  others: (Record<string, string> | undefined)[],\n): string[] {\n  const my = mine ?? {};\n  const diffKeys = new Set<string>();\n  for (const o of others) {\n    const od = o ?? {};\n    for (const k of Object.keys(my)) {\n      if (my[k] !== od[k]) {\n        diffKeys.add(k);\n      }\n    }\n    for (const k of Object.keys(od)) {\n      if (my[k] !== od[k]) {\n        diffKeys.add(k);\n      }\n    }\n  }\n  return [...diffKeys];\n}\n\nfunction renderWithDomain(\n  base: string,\n  keys: string[],\n  domain: Record<string, string> | undefined,\n): string {\n  if (keys.length === 0) return base;\n  const d = domain ?? {};\n  const pairs = keys.map((k) => `${k}=${d[k] ?? \"∅\"}`).join(\", \");\n  return `${base}[${pairs}]`;\n}\n\n/**\n * Minimal token distinguishing `mine` from `others`: label → name → only the differing domain keys.\n * Falls back to the bare label/name when indistinguishable at this dimension (another one covers it).\n */\nfunction deriveToken(mine: AxisIdentity, others: AxisIdentity[]): string {\n  const base = mine.label ?? mine.name;\n  if (mine.label !== undefined && others.every((o) => o.label !== mine.label)) return mine.label;\n  if (others.every((o) => o.name !== mine.name)) return base;\n  const dk = differingKeys(\n    mine.domain,\n    others.map((o) => o.domain),\n  );\n  if (dk.length > 0) return renderWithDomain(base, dk, mine.domain);\n  const ck = differingKeys(\n    mine.contextDomain,\n    others.map((o) => o.contextDomain),\n  );\n  if (ck.length > 0) return renderWithDomain(base, ck, mine.contextDomain);\n  return base;\n}\n\n/**\n * The chain's single root: the source-side axis of `linkers[0]`. A linker bridges two axis groups;\n * the side facing the next hop (`linkers[1]`, or the hit for a single-linker chain) is the target,\n * the other side is the source → its axis is the root. `undefined` if `linkers[0]` is not a\n * well-formed two-group linker.\n */\nexport function extractRoot(hit: PColumnSpec, linkers: PColumnSpec[]): AxisSpec | undefined {\n  const first = linkers[0];\n  if (first === undefined) return undefined;\n  const axes = first.axesSpec;\n  if (axes.length !== 2) return undefined;\n  const second = linkers[1] ?? hit;\n  return axes.find((a) => !second.axesSpec.some((b) => b.name === a.name));\n}\n\ntype Slot = { kind: \"root\" } | { kind: \"linker\"; i: number };\n\nconst ABSENT = \"__ABSENT__\"; // sentinel for \"this row has no value at this slot\"\n\n/** A colliding group: entries + their derived roots + original indices + the postfix formatter. */\ntype Group = {\n  entries: PostfixEntry[];\n  roots: (AxisSpec | undefined)[];\n  indices: number[];\n  format: LinkerFormatter;\n};\n\nfunction deriveSlotKey(group: Group, slot: Slot, row: number): string {\n  if (slot.kind === \"root\") {\n    const r = group.roots[row];\n    return r === undefined ? ABSENT : canonicalizeJson(getAxisId(r));\n  } else {\n    const l = group.entries[row].linkers?.[slot.i];\n    const id = l && extractLinkerIdentity(l);\n    return isNil(id) ? ABSENT : canonicalizeJson(id);\n  }\n}\n\nfunction deriveSlotToken(group: Group, slot: Slot, row: number): string | undefined {\n  if (slot.kind === \"root\") {\n    const r = group.roots[row];\n    if (r === undefined) return undefined;\n    const comp = group.roots\n      .filter((o, j) => j !== row && !isNil(o))\n      .map((o) => extractAxisIdentity(o!));\n    return deriveToken(extractAxisIdentity(r), comp);\n  }\n  const l = group.entries[row].linkers?.[slot.i];\n  const id = l && extractLinkerIdentity(l);\n  if (isNil(id)) return undefined; // unlabeled / absent linker → not renderable, skip\n  const comp = group.entries\n    .filter((_, j) => j !== row)\n    .map((e) => e.linkers?.[slot.i])\n    .map((x) => (x ? extractLinkerIdentity(x) : undefined))\n    .filter((x): x is AxisIdentity => !isNil(x));\n  return deriveToken(id, comp);\n}\n\nfunction getDiscriminates(group: Group, slot: Slot): boolean {\n  return new Set(group.entries.map((_, r) => deriveSlotKey(group, slot, r))).size > 1;\n}\n\n/** Render one row against a chosen slot set: the distinguishing root + linker pieces, formatted. */\nfunction renderRow(group: Group, slots: Slot[], row: number): string {\n  const rootSpec = group.roots[row];\n  const rootText = slots.some((s) => s.kind === \"root\")\n    ? deriveSlotToken(group, { kind: \"root\" }, row)\n    : undefined;\n  const root: LinkerPart<AxisSpec> | undefined =\n    rootSpec !== undefined && rootText !== undefined\n      ? { spec: rootSpec, text: rootText }\n      : undefined;\n\n  const linkers = slots\n    .filter((s): s is { kind: \"linker\"; i: number } => s.kind === \"linker\")\n    .sort((a, b) => a.i - b.i)\n    .map((s) => {\n      const spec = group.entries[row].linkers?.[s.i];\n      const text = deriveSlotToken(group, s, row);\n      return spec !== undefined && text !== undefined ? { spec, text } : undefined;\n    })\n    .filter((l): l is LinkerPart<PColumnSpec> => !isNil(l));\n\n  // No distinguishing pieces for this row → no postfix (don't invoke the formatter with empties).\n  if (root === undefined && linkers.length === 0) return \"\";\n  // A formatter may suppress the postfix by returning `undefined` or `\"\"`; `|| \"\"` collapses both\n  // to the same empty value so neither counts as a distinguishing token during slot escalation.\n  return group.format({ root, linkers }, group.entries[row].hit, group.indices[row]) || \"\";\n}\n\nfunction renderAll(group: Group, slots: Slot[]): string[] {\n  return group.entries.map((_, r) => renderRow(group, slots, r));\n}\n\nfunction allUnique(rendered: string[]): boolean {\n  return new Set(rendered).size === rendered.length;\n}\n\n/**\n * Minimal slot set that makes the group unique. Escalate by priority (root, then linkers by step),\n * then drop any redundant slot; render every row symmetrically against the result.\n *\n * KNOWN LIMITATION (review point): symmetric render can over-decorate a row in a mixed group (e.g.\n * `via Sample MapperA` where `via Sample` alone is already unique for that row). Per-row trimming is\n * a generalized `dropRedundantLinkerSuffix`; naive greedy trimming is unstable, so it's deferred.\n */\nfunction resolveGroup(\n  entries: PostfixEntry[],\n  indices: number[],\n  format: LinkerFormatter,\n): string[] {\n  const group: Group = {\n    entries,\n    roots: entries.map((e) =>\n      e.hit && e.linkers?.length ? extractRoot(e.hit, e.linkers) : undefined,\n    ),\n    indices,\n    format,\n  };\n  const maxLen = Math.max(0, ...entries.map((e) => e.linkers?.length ?? 0));\n\n  const slots: Slot[] = [\n    { kind: \"root\" },\n    ...Array.from({ length: maxLen }, (_, i): Slot => ({ kind: \"linker\", i })),\n  ];\n\n  const escalated = slots.reduce<Slot[]>(\n    (acc, slot) =>\n      allUnique(renderAll(group, acc)) || !getDiscriminates(group, slot)\n        ? acc\n        : (acc.push(slot), acc),\n    [],\n  );\n  const chosen = escalated.reduce<Slot[]>((acc, slot) => {\n    const trial = acc.filter((s) => s !== slot);\n    return allUnique(renderAll(group, trial)) ? trial : acc;\n  }, escalated);\n\n  return renderAll(group, chosen);\n}\n\n/**\n * Full label per entry: `stem` plus, where stems collide, a minimal postfix distinguishing the\n * linked columns by the difference between their sources.\n */\nexport function derivePostfixes(\n  entries: PostfixEntry[],\n  format: LinkerFormatter = defaultLinkerFormatter,\n): string[] {\n  const groups = entries.reduce<Map<string, number[]>>((acc, e, idx) => {\n    const key = `${e.stem}\\u0000${e.marker ?? \"\"}`;\n    return acc.set(key, [...(acc.get(key) ?? []), idx]);\n  }, new Map());\n\n  const postfix = [...groups.values()].reduce<Map<number, string>>((acc, idxs) => {\n    if (idxs.length < 2) return acc; // no other entry shares this stem and marker — no postfix\n    const resolved = resolveGroup(\n      idxs.map((i) => entries[i]),\n      idxs,\n      format,\n    );\n    return idxs.reduce((m, i, k) => m.set(i, resolved[k]), acc);\n  }, new Map());\n\n  return entries.map((e, i) => {\n    const p = postfix.get(i);\n    return p ? `${e.stem} ${p}` : e.stem;\n  });\n}\n"],"mappings":"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"}