{"version":3,"file":"createPlDataTableV3.cjs","names":["readPlDataTableUserParams","upgradePlDataTableStateV2","deriveAllLabels","isColumnHidden","evaluateRules","createColumnResolver","collectLinkerColumns","canonicalizeAxisId","createSearchFilter","collectSearchColumns","getEffectiveVisibility","toRuleColumn","joinFilters","createSheetFilters","createPTableDefV3","uniq","extractPObjectId","discoverLabelColumns","dedupColumns","isPlainObject","discoverTableColumns","hasSingleDataColumn","uniqueBy","getResultPoolDatasetAxes","findPeerLinks","describePeerLinks","hitQualifications","queriesQualifications","buildDataStatusMap","getOrderPriority","isNil","collectFilterSpecColumns"],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  FilterSpecNode,\n  PObjectId,\n  PTableColumnId,\n  PTableColumnIdColumn,\n  PTableSorting,\n  MultiColumnSelector,\n  ColumnSelector,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  canonicalizeAxisId,\n  dedupColumns,\n  extractPObjectId,\n  uniqueBy,\n} from \"@milaboratories/pl-model-common\";\nimport { collectFilterSpecColumns } from \"../../../filters/traverse\";\nimport { createColumnResolver, type ColumnResolver } from \"../columnResolver\";\nimport type { RenderCtxBase } from \"../../../render\";\nimport type {\n  PlDataTableColumnsMeta,\n  PlDataTableFilters,\n  PlDataTableFilterSpecLeaf,\n  PlDataTableModel,\n} from \"../typesV8\";\nimport { upgradePlDataTableStateV2 } from \"../state-migration\";\nimport type { PlDataTableStateV2 } from \"../state-migration\";\nimport {\n  collectSearchColumns,\n  createSearchFilter,\n  createSheetFilters,\n  joinFilters,\n  readPlDataTableUserParams,\n} from \"../tableParams\";\nimport type { MatchingMode } from \"@milaboratories/pl-model-common\";\nimport {\n  hasSingleDataColumn,\n  hitQualifications,\n  collectLinkerColumns,\n  describePeerLinks,\n  findPeerLinks,\n  getResultPoolDatasetAxes,\n  queriesQualifications,\n  type ColumnRecipe,\n} from \"../../../columns\";\nimport type { DeriveLabelsOptions } from \"../../../labels/derive_distinct_labels\";\nimport {\n  deriveAllLabels,\n  evaluateRules,\n  getEffectiveVisibility,\n  getOrderPriority,\n  isColumnHidden,\n  buildDataStatusMap,\n  toRuleColumn,\n  type LabelableColumn,\n} from \"./utils\";\nimport { createPTableDefV3 } from \"./createPTableDefV3\";\nimport {\n  discoverLabelColumns,\n  discoverTableColumns,\n  type DiscoverTableColumnOptions,\n} from \"./discoverColumns\";\nimport { isNil, isPlainObject, type Nil } from \"@milaboratories/helpers\";\nimport { uniq } from \"es-toolkit\";\n\nexport type createPlDataTableOptionsV3 = (\n  | {\n      columns: Nil | DiscoverTableColumnOptions;\n    }\n  | {\n      primaryColumns: ColumnRecipe[];\n      columns: Nil | ColumnRecipe[];\n    }\n) & {\n  tableState?: PlDataTableStateV2;\n\n  filters?: PlDataTableFilters;\n  sorting?: PTableSorting[];\n  primaryJoinType?: \"inner\" | \"full\";\n\n  labelsOptions?: DeriveLabelsOptions;\n  displayOptions?: ColumnsDisplayOptions;\n};\n\n/** Structured source config — selectors/anchors instead of raw ColumnsSource. */\nexport type ColumnsSelectorConfig = {\n  include?: MultiColumnSelector | MultiColumnSelector[];\n  exclude?: MultiColumnSelector | MultiColumnSelector[];\n  mode?: MatchingMode;\n  maxHops?: number;\n};\n\nexport type ColumnsDisplayOptions = {\n  /** Column ordering rules. Higher priority = further left. First matching rule wins. */\n  ordering?: ColumnOrderRule[];\n  /** Column visibility rules. First matching rule wins. Unmatched columns use default visibility. */\n  visibility?: ColumnVisibilityRule[];\n};\n\nexport type ColumnOrderRule = {\n  match: ColumnSelector;\n  /** Higher number = further left in table */\n  priority: number;\n};\n\nexport type ColumnVisibilityRule = {\n  match: ColumnSelector;\n  visibility: \"default\" | \"optional\" | \"hidden\";\n};\n\nexport function createPlDataTableV3<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  options: createPlDataTableOptionsV3,\n): PlDataTableModel | undefined {\n  const params = readPlDataTableUserParams(upgradePlDataTableStateV2(options.tableState));\n  const primaryJoinType = options.primaryJoinType ?? \"full\";\n\n  const resolved = resolveInputColumns(ctx, options);\n  if (resolved === undefined) return undefined;\n  const { primary, secondary } = resolved;\n  if (primary.length === 0) return undefined;\n\n  const { direct, linked } = splitByTopology(secondary);\n\n  const allColumns = [...primary, ...secondary];\n  const labelable = allColumns.map(toLabelableColumn);\n  // From all columns: a hidden one still shows when sorted, filtered or made visible by a rule.\n  const linkHints = collectLinkHints(labelable);\n  const derivedLabels = deriveAllLabels({\n    // Skip hidden columns when deriving labels — they don't appear in the\n    // table, so they shouldn't influence label disambiguation (#1623).\n    // The link icon and its hover text tell same-named columns apart, so they get no \"via\" text.\n    columns: labelable\n      .filter((c) => !isColumnHidden(c.spec))\n      .map((c) => ({ ...c, marker: linkHints.get(c.id) })),\n    deriveLabelsOptions: {\n      includeNativeLabel: true,\n      ...options.labelsOptions,\n    },\n  });\n\n  // Rule-based visibility/order maps (keyed by bare PObjectId). Computed once\n  // here: `computeHiddenColumns` needs visibility to decide the visible set,\n  // and `buildColumnsMeta` (below, once the visible set is known) reuses both.\n  const allColumnsForRules = [...primary, ...direct, ...linked, ...collectLinkerSnapshots(linked)];\n  const visibilityByColId = evaluateRules(\n    options.displayOptions?.visibility ?? [],\n    allColumnsForRules,\n  );\n  const orderByColId = evaluateRules(options.displayOptions?.ordering ?? [], allColumnsForRules);\n\n  const resolver = createColumnResolver([\n    ...primary,\n    ...direct,\n    ...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc]),\n  ]);\n\n  const tableColumns = [...primary, ...direct, ...linked];\n  // The table shows only the axes of its primary columns.\n  const primaryAxisKeys = new Set(\n    primary.flatMap((c) => c.getSpec().axesSpec.map((a) => canonicalizeAxisId(a))),\n  );\n  const searchFilter = createSearchFilter(\n    params.searchString,\n    collectSearchColumns({\n      columns: tableColumns.map((c) => ({\n        id: c.id,\n        spec: c.getSpec(),\n        visibility: getEffectiveVisibility(toRuleColumn(c), visibilityByColId) ?? \"default\",\n      })),\n      isAxisHidden: (axis) =>\n        !primaryAxisKeys.has(canonicalizeAxisId(axis)) || isColumnHidden(axis),\n      sheetAxes: params.sheetsState.map((sheet) => sheet.axisId),\n      hiddenColIds: params.hiddenColIds,\n    }),\n  );\n\n  const remapedDefaultFilters = remapFilterColumnIds(options.filters, resolver);\n  const filters = filterFilters(\n    joinFilters([\n      ...createSheetFilters(params.sheetsState),\n      params.userFilters,\n      searchFilter,\n      params.defaultFilters ?? remapedDefaultFilters,\n    ]),\n    resolver,\n  );\n\n  const sorting = filterSorting(\n    resolveSorting(params.sorting, remapSortingColumnIds(options.sorting, resolver)),\n    resolver,\n  );\n\n  const fullDef = createPTableDefV3({\n    primaryJoinType,\n    primary,\n    secondary: [...direct, ...linked],\n    filters,\n    sorting,\n  });\n\n  const fullHandle = ctx.createPTableV2(fullDef);\n  // TODO: is workaround for dropdown suggestions.\n  // Pframe have not equivalent data for columns relativly to Ptable.\n  // PFrame is the physical column registry — one entry per bare PObjectId,\n  // so strip the rich recipe ids down to their physical leaf id and dedupe:\n  // multiple discovered variants of the same hit collapse to the same bare id.\n  const pframeHandle = ctx.createPFrame(\n    uniq([\n      ...primary.map((v) => extractPObjectId(v.id)),\n      ...direct.map((v) => extractPObjectId(v.id)),\n      ...linked.map((v) => extractPObjectId(v.id)),\n    ]),\n  );\n\n  const hiddenColumnIds = computeHiddenColumns({\n    columns: tableColumns,\n    visibilityByColId,\n    sorting,\n    filters,\n    hiddenSpecs: params.hiddenColIds,\n  });\n\n  const visible = {\n    primary,\n    direct: direct.filter((c) => !hiddenColumnIds.has(c.id)),\n    linked: linked.filter((c) => !hiddenColumnIds.has(c.id)),\n  };\n  const visibleDef = createPTableDefV3({\n    primaryJoinType,\n    primary,\n    secondary: [...visible.direct, ...visible.linked],\n    filters,\n    sorting,\n  });\n  const visibleHandle = ctx.createPTableV2(visibleDef);\n\n  // Built here, where the visible set is known: per-column data status is\n  // computed for visible columns only (the probe is meaningful only for what\n  // the user sees), while label/visibility/order/axes cover all columns.\n  const columnsMeta = buildColumnsMeta({\n    fullColumns: [...primary, ...direct, ...linked],\n    visibleColumns: [...visible.primary, ...visible.direct, ...visible.linked],\n    primaryColumns: primary,\n    derivedLabels,\n    linkHints,\n    visibilityByColId,\n    orderByColId,\n  });\n\n  return {\n    sourceId: params.sourceId,\n    fullTableHandle: fullHandle,\n    fullPframeHandle: pframeHandle,\n    visibleTableHandle: visibleHandle,\n    defaultFilters: remapedDefaultFilters,\n    columnsMeta,\n  } satisfies PlDataTableModel;\n}\n\ntype ResolvedColumns = {\n  readonly primary: ColumnRecipe[];\n  readonly secondary: ColumnRecipe[];\n};\n\n/** Normalize either option branch into a {primary, secondary} pair of recipes. */\nfunction resolveInputColumns<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  options: createPlDataTableOptionsV3,\n): undefined | ResolvedColumns {\n  if (\"primaryColumns\" in options) {\n    const primary = options.primaryColumns;\n    const secondary = options.columns ?? [];\n    const labels = discoverLabelColumns(ctx, primary);\n    // Exclude from secondary anything already present in primary: a label\n    // column the block hands in as primary can be re-discovered here as a\n    // label for that same axis, landing in the table twice with the same id.\n    const primaryIds = new Set(primary.map((c) => c.id));\n    return {\n      primary,\n      secondary: dedupColumns(\n        [...secondary, ...labels].filter((c) => !primaryIds.has(c.id)),\n        (c) => c.id,\n        (c) => c.getSpec(),\n      ),\n    };\n  }\n\n  if (isPlainObject(options.columns)) {\n    return discoverTableColumns(ctx, options.columns);\n  }\n\n  return undefined;\n}\n\n/** Split secondary recipes by query topology: leaves (no linker chain) vs joined. */\nfunction splitByTopology(columns: ColumnRecipe[]): {\n  direct: ColumnRecipe[];\n  linked: ColumnRecipe[];\n} {\n  const direct: ColumnRecipe[] = [];\n  const linked: ColumnRecipe[] = [];\n  for (const c of columns) {\n    if (hasSingleDataColumn(c)) direct.push(c);\n    else linked.push(c);\n  }\n  return { direct, linked };\n}\n\n/** All linker recipes across the given linked columns, deduped by id. */\nfunction collectLinkerSnapshots(linked: ColumnRecipe[]): ColumnRecipe[] {\n  return uniqueBy(\n    linked.flatMap((c) => collectLinkerColumns(c)),\n    (c) => c.id,\n  );\n}\n\n/** Link icon hover text per column, for columns reached through at least one peer link. */\nfunction collectLinkHints(columns: LabelableColumn[]): Map<ColumnUniversalId, string> {\n  if (!columns.some((c) => c.linkerPath?.length)) return new Map();\n  const datasetAxes = getResultPoolDatasetAxes();\n  return new Map(\n    columns.flatMap((c) => {\n      const links = findPeerLinks(c.linkerPath?.map((step) => step.linker.spec) ?? [], datasetAxes);\n      return links.length > 0 ? [[c.id, describePeerLinks(links)] as const] : [];\n    }),\n  );\n}\n\nfunction toLabelableColumn(col: ColumnRecipe): LabelableColumn {\n  return {\n    id: col.id,\n    spec: col.getSpec(),\n    linkerPath: collectLinkerColumns(col).map((linker) => ({\n      linker: { spec: linker.getSpec() },\n    })),\n    qualifications: {\n      forHit: [...hitQualifications(col)],\n      forQueries: queriesQualifications(col),\n    },\n  };\n}\n\n/**\n * Compute display metadata as a sidecar keyed by each emitted column's\n * `ColumnUniversalId` (and axis `AxisId`), instead of baking it into the specs\n * via `withSpecs`. Spec overrides change a recipe's id, so the same physical\n * column reached two ways would diverge into two ids and render twice; keeping\n * meta out of the spec preserves identity and lets dedup collapse such cases.\n * The UI overlays this onto the engine-emitted specs at render time.\n */\nfunction buildColumnsMeta(params: {\n  /** Every column in the table (primary + secondary) — drives `columns` and `axes`. */\n  fullColumns: ColumnRecipe[];\n  /** The visible subset — `status` is probed for these only. */\n  visibleColumns: ColumnRecipe[];\n  /** The primary join columns — their axes are the visible index; all other axes are hidden. */\n  primaryColumns: ColumnRecipe[];\n  derivedLabels: Record<string, string>;\n  linkHints: Map<ColumnUniversalId, string>;\n  visibilityByColId: Map<PObjectId, ColumnVisibilityRule>;\n  orderByColId: Map<PObjectId, ColumnOrderRule>;\n}): PlDataTableColumnsMeta {\n  const { fullColumns, visibleColumns, primaryColumns, derivedLabels, linkHints } = params;\n  const { visibilityByColId, orderByColId } = params;\n  // Status only for visible columns — the probe is meaningful only for what the\n  // user actually sees; non-visible columns get no `status`.\n  const visibleStatus = buildDataStatusMap(visibleColumns);\n\n  const columns = fullColumns.reduce<PlDataTableColumnsMeta[\"columns\"]>((acc, c) => {\n    const rc = toRuleColumn(c);\n    acc[c.id] = {\n      label: derivedLabels[c.id],\n      visibility: getEffectiveVisibility(rc, visibilityByColId),\n      order: getOrderPriority(rc, orderByColId),\n      status: visibleStatus[c.id],\n      linkHint: linkHints.get(c.id),\n    };\n    return acc;\n  }, {});\n\n  // Only primary columns declare the table's visible axes. Any axis introduced\n  // solely by a secondary column (a linker-bridge axis, or a distinct-domain\n  // copy) is flagged hidden — otherwise it renders as a second index axis.\n  const primaryAxisKeys = new Set(\n    primaryColumns.flatMap((c) => c.getSpec().axesSpec.map((a) => canonicalizeAxisId(a))),\n  );\n  const axes = fullColumns.reduce<PlDataTableColumnsMeta[\"axes\"]>(\n    (acc, c) =>\n      c.getSpec().axesSpec.reduce((inner, ax) => {\n        const key = canonicalizeAxisId(ax);\n        if (inner[key] === undefined) inner[key] = { hidden: !primaryAxisKeys.has(key) };\n        return inner;\n      }, acc),\n    {},\n  );\n\n  return { columns, axes };\n}\n\n/** Drop filter leaves whose column references cannot be resolved; rewrite the\n *  resolvable ones through the resolver. Prune empty and/or/not groups. */\nfunction filterFilters(\n  filters: Nil | PlDataTableFilters,\n  resolver: ColumnResolver,\n): Nil | PlDataTableFilters {\n  if (isNil(filters)) return filters;\n\n  const rewriteLeaf = (leaf: PlDataTableFilterSpecLeaf): Nil | PlDataTableFilterSpecLeaf => {\n    if (leaf.type === undefined) return leaf;\n    const result = { ...leaf };\n    if (\"column\" in result) {\n      const c = resolver(result.column);\n      if (isNil(c)) return undefined;\n      result.column = c;\n    }\n    if (\"rhs\" in result) {\n      const c = resolver(result.rhs);\n      if (isNil(c)) return undefined;\n      result.rhs = c;\n    }\n    return result;\n  };\n\n  const prune = (node: PlDataTableFilterNode): Nil | PlDataTableFilterNode => {\n    if (node.type === \"and\" || node.type === \"or\") {\n      const kept = node.filters\n        .map((f) => prune(f))\n        .filter((f): f is PlDataTableFilterNode => !isNil(f));\n      if (kept.length === 0) return undefined;\n      return { type: node.type, filters: kept };\n    }\n    if (node.type === \"not\") {\n      const inner = prune(node.filter);\n      return isNil(inner) ? undefined : { type: \"not\", filter: inner };\n    }\n    return rewriteLeaf(node);\n  };\n\n  return prune(filters) as Nil | PlDataTableFilters;\n}\n\n/** Pick user sorting from state if set, otherwise fall back to options default.\n *  null = user has not touched sorting → use default;\n *  [] = user has explicitly cleared sorting → no sorting (default ignored). */\nfunction resolveSorting(\n  userSorting: Nil | PTableSorting[],\n  defaultSorting: Nil | PTableSorting[],\n): PTableSorting[] {\n  return (isNil(userSorting) ? defaultSorting : userSorting) ?? [];\n}\n\n/** Rewrite sorting entries through the resolver; drop those that fail to resolve. */\nfunction filterSorting(sorting: PTableSorting[], resolver: ColumnResolver): PTableSorting[] {\n  return sorting.flatMap((s) => {\n    const col = resolver(s.column);\n    return isNil(col) ? [] : [{ ...s, column: col }];\n  });\n}\n\n/** Determine which columns should be hidden based on state or optional-column defaults.\n *  Keyed by the recipe's logical {@link ColumnUniversalId} (rich) — variants of\n *  the same physical column are independently visible/hidden. */\nfunction computeHiddenColumns(params: {\n  columns: ColumnRecipe[];\n  visibilityByColId: Map<PObjectId, ColumnVisibilityRule>;\n  sorting: Nil | PTableSorting[];\n  filters: Nil | PlDataTableFilters;\n  hiddenSpecs: Nil | PTableColumnId[];\n}): Set<ColumnUniversalId> {\n  const { columns, visibilityByColId, sorting, filters, hiddenSpecs } = params;\n  const visibilityOf = (c: ColumnRecipe) =>\n    getEffectiveVisibility(toRuleColumn(c), visibilityByColId);\n  const alwaysHidden = columns.filter((c) => visibilityOf(c) === \"hidden\").map((c) => c.id);\n  const optionalHidden = !isNil(hiddenSpecs)\n    ? hiddenSpecs.filter((s): s is PTableColumnIdColumn => s.type === \"column\").map((s) => s.id)\n    : columns.filter((c) => visibilityOf(c) === \"optional\").map((c) => c.id);\n  const initial = [...alwaysHidden, ...optionalHidden];\n  const preserved = collectPreservedColumnIds(sorting, filters);\n\n  return new Set(initial.filter((id) => !preserved.has(id)));\n}\n\n/** Collect IDs of columns that must remain visible (sorted, filtered). */\nfunction collectPreservedColumnIds(\n  sorting: Nil | PTableSorting[],\n  filters: Nil | PlDataTableFilters,\n): Set<ColumnUniversalId> {\n  const sortedIds = (sorting ?? [])\n    .map((s) => s.column)\n    .filter((c): c is PTableColumnIdColumn => c.type === \"column\")\n    .map((c) => c.id);\n\n  const filterIds = !isNil(filters)\n    ? collectFilterSpecColumns(filters).flatMap((c) => (c.type === \"column\" ? [c.id] : []))\n    : [];\n\n  return new Set<ColumnUniversalId>([...sortedIds, ...filterIds]);\n}\n\n/** Remap column references in sorting entries through the resolver.\n *  Unresolved entries are dropped with a warning (best-effort contract). */\nfunction remapSortingColumnIds(\n  sorting: Nil | PTableSorting[],\n  resolver: ColumnResolver,\n): Nil | PTableSorting[] {\n  return sorting?.flatMap((s) => {\n    const col = resolver(s.column);\n    if (isNil(col)) {\n      console.warn(\n        `Sorting column ${JSON.stringify(s.column)} does not match any discovered column — dropped.`,\n      );\n      return [];\n    }\n    return [{ ...s, column: col }];\n  });\n}\n\ntype PlDataTableFilterNode = FilterSpecNode<PlDataTableFilterSpecLeaf>;\n\n/** Remap column references in a filter tree through the resolver.\n *  Unresolved leaves are dropped with a warning; empty groups are pruned. */\nfunction remapFilterColumnIds(\n  filters: Nil | PlDataTableFilters,\n  resolver: ColumnResolver,\n): Nil | PlDataTableFilters {\n  if (isNil(filters)) return filters;\n\n  const mapLeaf = (leaf: PlDataTableFilterSpecLeaf): Nil | PlDataTableFilterSpecLeaf => {\n    if (leaf.type === undefined) return leaf;\n    const result = { ...leaf };\n    if (\"column\" in result) {\n      const c = resolver(result.column);\n      if (isNil(c)) {\n        console.warn(\n          `Filter column ${JSON.stringify(result.column)} does not match any discovered column — dropped.`,\n        );\n        return undefined;\n      }\n      result.column = c;\n    }\n    if (\"rhs\" in result) {\n      const c = resolver(result.rhs);\n      if (isNil(c)) {\n        console.warn(\n          `Filter rhs ${JSON.stringify(result.rhs)} does not match any discovered column — dropped.`,\n        );\n        return undefined;\n      }\n      result.rhs = c;\n    }\n    return result;\n  };\n\n  const prune = (node: PlDataTableFilterNode): Nil | PlDataTableFilterNode => {\n    if (node.type === \"and\" || node.type === \"or\") {\n      const kept = node.filters\n        .map((f) => prune(f))\n        .filter((f): f is PlDataTableFilterNode => !isNil(f));\n      if (kept.length === 0) return undefined;\n      return { type: node.type, filters: kept };\n    }\n    if (node.type === \"not\") {\n      const inner = prune(node.filter);\n      return isNil(inner) ? undefined : { type: \"not\", filter: inner };\n    }\n    return mapLeaf(node);\n  };\n\n  return prune(filters) as Nil | PlDataTableFilters;\n}\n"],"mappings":"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"}