@platforma-sdk/model 1.33.8 → 1.33.14

package/src/components/PFrameForGraphs.ts

@@ -1,11 +1,8 @@
 import type {
-  AxisId,
-  CanonicalizedJson,
+  AxisId, CanonicalizedJson,
   DataInfo,
   PColumn,
-  PColumnIdAndSpec,
   PColumnSpec,
-  PColumnSpecId,
   PColumnValues,
   PFrameHandle,
   PObjectId,
@@ -13,13 +10,11 @@ import type {
 import {
   canonicalizeJson,
   getAxisId,
-  getPColumnSpecId,
-  isPColumn,
-  matchAxisId,
-  parseJson,
+  matchAxisId, parseJson,
 } from '@milaboratories/pl-model-common';
-import type { RenderCtx } from '../render';
-import { TreeNodeAccessor } from '../render';
+import type { PColumnDataUniversal, RenderCtx } from '../render';
+import { PColumnCollection, TreeNodeAccessor } from '../render';
+import { isLabelColumn } from './PlDataTable';
 
 /** Create id for column copy with added keys in axes domains */
 const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
@@ -56,104 +51,92 @@ export function isLinkerColumn(column: PColumnSpec) {
   return column.axesSpec.length === 2 && column.annotations?.[LINKER_COLUMN_ANNOTATION] === 'true';
 }
 
-export type LinkerColumnsMap = Map<CanonicalizedJson<AxisId>, Map<CanonicalizedJson<AxisId>, PColumnIdAndSpec>>;
-export function getLinkerColumnsMap(linkerColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[]) {
+export const IS_VIRTUAL_COLUMN = 'pl7.app/graph/isVirtual'; // annotation for column duplicates with extended domains
+export const LABEL_ANNOTATION = 'pl7.app/label';
+export const LINKER_COLUMN_ANNOTATION = 'pl7.app/isLinkerColumn';
+
+export type LinkerColumnsMap = Map<CanonicalizedJson<AxisId>, Set<CanonicalizedJson<AxisId>>>;
+export function getLinkerColumnsMap(linkerColumns: PColumn<PColumnDataUniversal>[]) {
   const resultMap: LinkerColumnsMap = new Map();
-  for (const { id, spec } of linkerColumns) {
-    const [idA, idB] = spec.axesSpec.map(getAxisId).map(canonicalizeJson);
-    if (!resultMap.has(idA)) {
-      resultMap.set(idA, new Map());
-    }
-    if (!resultMap.has(idB)) {
-      resultMap.set(idB, new Map());
+  for (const { spec } of linkerColumns) {
+    const axisIds = spec.axesSpec.map(getAxisId).map(canonicalizeJson);
+    axisIds.forEach((id) => {
+      if (!resultMap.has(id)) {
+        resultMap.set(id, new Set());
+      }
+    });
+    for (let i = 0; i < axisIds.length - 1; i++) {
+      for (let j = i + 1; j < axisIds.length; j++) {
+        const id1 = axisIds[i];
+        const id2 = axisIds[j];
+        resultMap.get(id1)?.add(id2);
+        resultMap.get(id2)?.add(id1);
+      }
     }
-    resultMap.get(idA)?.set(idB, { columnId: id, spec })
-    resultMap.get(idB)?.set(idA, { columnId: id, spec })
   }
   return resultMap;
 }
 
-export function hasPathWithLinkerColumns(
-  linkerColumnsMap: LinkerColumnsMap,
-  startId: AxisId,
-  endId: AxisId,
-): boolean {
+export function getAvailableWithLinkersAxes(
+  linkerColumns: PColumn<PColumnDataUniversal>[],
+  blockAxes: Map<CanonicalizedJson<AxisId>, AxisId>,
+): Map<CanonicalizedJson<AxisId>, AxisId> {
+  const linkerColumnsMap = getLinkerColumnsMap(linkerColumns);
   const linkerColumnsMapIds = [...linkerColumnsMap.keys()].map(parseJson);
-  const startIdMatched = linkerColumnsMapIds.find((id) => matchAxisId(startId, id));
-  if (!startIdMatched) return false;
-
-  const startKey = canonicalizeJson(getAxisId(startIdMatched));
-  const visited = new Set([startKey]);
-  let nextKeys = [startKey];
+  const startKeys: CanonicalizedJson<AxisId>[] = [];
+  for (const startId of blockAxes.values()) {
+    const matched = linkerColumnsMapIds.find((id) => matchAxisId(startId, id));
+    if (matched) {
+      startKeys.push(canonicalizeJson(matched)); // linker column can contain fewer domains than in block's columns, it's fixed on next step in enrichCompatible
+    }
+  }
+  const visited: Set<CanonicalizedJson<AxisId>> = new Set(startKeys);
+  const addedAvailableAxes: Map<CanonicalizedJson<AxisId>, AxisId> = new Map();
+  let nextKeys = [...startKeys];
 
   while (nextKeys.length) {
     const next: CanonicalizedJson<AxisId>[] = [];
     for (const nextKey of nextKeys) {
-      for (const availableKey of linkerColumnsMap.get(nextKey)?.keys() ?? []) {
-        const availableId = parseJson(availableKey);
-        if (matchAxisId(endId, availableId)) return true;
+      for (const availableKey of linkerColumnsMap.get(nextKey) ?? []) {
         if (!visited.has(availableKey)) {
           next.push(availableKey);
           visited.add(availableKey);
+          addedAvailableAxes.set(availableKey, parseJson(availableKey));
         }
       }
     }
     nextKeys = next;
   }
-  return false;
-}
-
-/** Check if axes of secondary column are exactly in axes of main column */
-function checkFullCompatibility(
-  mainColumn: PColumnSpec,
-  secondaryColumn: PColumnSpec,
-  linkerColumnsMap?: LinkerColumnsMap,
-): boolean {
-  const mainAxesIds = mainColumn.axesSpec.map(getAxisId);
-  const secondaryAxesIds = secondaryColumn.axesSpec.map(getAxisId);
-  // with fixed axes (sliced columns) in data-mapping there is enough to have only one axis in intersection
-  return secondaryAxesIds.some((id) => mainAxesIds.some((mainId) => matchAxisId(mainId, id) && matchAxisId(id, mainId)))
-    || (!!linkerColumnsMap && secondaryAxesIds.some((id) => mainAxesIds.some((mainId) => hasPathWithLinkerColumns(linkerColumnsMap, mainId, id))));
+  return addedAvailableAxes;
 }
-
-/** Check if axes of secondary column are in axes of main column, but they can have compatible difference in domains */
-function checkCompatibility(
-  mainColumn: PColumnSpec,
-  secondaryColumn: PColumnSpec,
-  linkerColumnsMap?: LinkerColumnsMap,
-): boolean {
-  const mainAxesIds = mainColumn.axesSpec.map(getAxisId);
-  const secondaryAxesIds = secondaryColumn.axesSpec.map(getAxisId);
-  // with fixed axes (sliced columns) in data-mapping there is enough to have only one axis in intersection
-  return secondaryAxesIds.some((id) => mainAxesIds.some((mainId) => matchAxisId(mainId, id)))
-    || (!!linkerColumnsMap && secondaryAxesIds.some((id) => mainAxesIds.some((mainId) => hasPathWithLinkerColumns(linkerColumnsMap, mainId, id))));
+/** Add columns with fully compatible axes created from partial compatible ones */
+export function enrichCompatible(blockAxes: Map<string, AxisId>, columns: PColumn<PColumnDataUniversal>[]) {
+  const result: PColumn<PColumnDataUniversal>[] = [];
+  columns.forEach((column) => {
+    result.push(...getAdditionalColumnsForColumn(blockAxes, column));
+  });
+  return result;
 }
 
-export const IS_VIRTUAL_COLUMN = 'pl7.app/graph/isVirtual'; // annotation for column duplicates with extended domains
-export const LABEL_ANNOTATION = 'pl7.app/label';
-export const LINKER_COLUMN_ANNOTATION = 'pl7.app/isLinkerColumn';
+function getAdditionalColumnsForColumn(
+  blockAxes: Map<string, AxisId>,
+  column: PColumn<PColumnDataUniversal>,
+): PColumn<PColumnDataUniversal>[] {
+  const columnAxesIds = column.spec.axesSpec.map(getAxisId);
 
-/** Main column can have additional domains, if secondary column (meta-column) has all axes match main column axes
- we can add its copy with missed domain fields for compatibility */
-function getAdditionalColumnsForPair(
-  mainColumn: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>,
-  secondaryColumn: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>,
-  linkerColumnsMap?: LinkerColumnsMap,
-): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] {
-  const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
-  const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
-
-  const isFullCompatible = checkFullCompatibility(mainColumn.spec, secondaryColumn.spec, linkerColumnsMap);
-  if (isFullCompatible) { // in this case it isn't necessary to add more columns
-    return [];
-  }
-  const isCompatible = checkCompatibility(mainColumn.spec, secondaryColumn.spec, linkerColumnsMap);
-  if (!isCompatible) { // in this case it is impossible to add some compatible column
-    return [];
+  if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) {
+    return [column]; // the column is compatible with its own domains without modifications
   }
+
   // options with different possible domains for every axis of secondary column
-  const secondaryIdsOptions = secondaryAxesIds.map((id) => {
-    return mainAxesIds.filter((mainId) => matchAxisId(mainId, id));
+  const secondaryIdsOptions = columnAxesIds.map((id) => {
+    const result = [];
+    for (const [_, mainId] of blockAxes) {
+      if (matchAxisId(mainId, id) && !matchAxisId(id, mainId)) {
+        result.push(mainId);
+      }
+    }
+    return result;
   });
   // all possible combinations of axes with added domains
   const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
@@ -164,7 +147,7 @@ function getAdditionalColumnsForPair(
   const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
     const addedSet = new Set<string>();
     idsList.map((axisId, idx) => {
-      const d1 = secondaryColumn.spec.axesSpec[idx].domain;
+      const d1 = column.spec.axesSpec[idx].domain;
       const d2 = axisId.domain;
       Object.entries(d2 ?? {}).forEach(([key, value]) => {
         if (d1?.[key] === undefined) {
@@ -175,7 +158,7 @@ function getAdditionalColumnsForPair(
       });
       return ({
         ...axisId,
-        annotations: secondaryColumn.spec.axesSpec[idx].annotations,
+        annotations: column.spec.axesSpec[idx].annotations,
       });
     });
     return addedSet;
@@ -186,10 +169,10 @@ function getAdditionalColumnsForPair(
     }
   });
 
-  return secondaryIdsVariants.map((idsList, idx) => {
-    const id = colId(secondaryColumn.id, idsList.map((id) => id.domain));
+  const additionalColumns = secondaryIdsVariants.map((idsList, idx) => {
+    const id = colId(column.id, idsList.map((id) => id.domain));
 
-    const label = secondaryColumn.spec.annotations?.[LABEL_ANNOTATION] ?? '';
+    const label = column.spec.annotations?.[LABEL_ANNOTATION] ?? '';
     const labelDomainPart = ([...addedByVariantsDomainValues[idx]])
       .filter((str) => addedNotToAllVariantsDomainValues.has(str))
       .sort()
@@ -197,7 +180,7 @@ function getAdditionalColumnsForPair(
       .join(' / ');
 
     const annotations: Record<string, string> = {
-      ...secondaryColumn.spec.annotations,
+      ...column.spec.annotations,
       [IS_VIRTUAL_COLUMN]: 'true',
     };
     if (label || labelDomainPart) {
@@ -207,101 +190,58 @@ function getAdditionalColumnsForPair(
     return {
       id: id as PObjectId,
       spec: {
-        ...secondaryColumn.spec,
+        ...column.spec,
         axesSpec: idsList.map((axisId, idx) => ({
           ...axisId,
-          annotations: secondaryColumn.spec.axesSpec[idx].annotations,
+          annotations: column.spec.axesSpec[idx].annotations,
         })),
         annotations,
       },
-      data: secondaryColumn.data,
+      data: column.data,
     };
   });
-}
 
-export function getAdditionalColumns(
-  columns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[],
-  linkerColumnsMap: LinkerColumnsMap = new Map(),
-): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] {
-  const additionalColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] = [];
-  for (let i = 0; i < columns.length; i++) {
-    for (let j = i + 1; j < columns.length; j++) {
-      const column1 = columns[i];
-      const column2 = columns[j];
-
-      // check if column 1 is meta for column 2 or backward
-      additionalColumns.push(
-        ...getAdditionalColumnsForPair(column1, column2, linkerColumnsMap),
-        ...getAdditionalColumnsForPair(column2, column1, linkerColumnsMap),
-      );
-    }
-  }
-  return additionalColumns;
-}
-
-export function enrichColumnsWithCompatible(
-  mainColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[],
-  secondaryColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[],
-  linkerColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] = [],
-  linkerColumnsMap: LinkerColumnsMap = new Map(),
-): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] {
-  const mainColumnsIds = new Set<PObjectId>();
-  const mainColumnsBySpec = new Map<CanonicalizedJson<PColumnSpecId>, typeof mainColumns[number]>();
-  mainColumns.forEach((column) => {
-    mainColumnsIds.add(column.id);
-    mainColumnsBySpec.set(canonicalizeJson(getPColumnSpecId(column.spec)), column);
-  });
-
-  const secondaryColumnsBySpec = new Map<CanonicalizedJson<PColumnSpecId>, typeof secondaryColumns[number]>();
-  for (const secondaryColumn of secondaryColumns) {
-    if (mainColumnsIds.has(secondaryColumn.id)) continue;
-
-    const spec = canonicalizeJson(getPColumnSpecId(secondaryColumn.spec));
-    if (mainColumnsBySpec.has(spec)) continue;
-
-    for (const mainColumn of mainColumnsBySpec.values()) {
-      if (checkCompatibility(mainColumn.spec, secondaryColumn.spec, linkerColumnsMap)) {
-        secondaryColumnsBySpec.set(spec, secondaryColumn);
-        break;
-      }
-    }
-  }
-
-  for (const linkerColumn of linkerColumns) {
-    if (mainColumnsIds.has(linkerColumn.id)) continue;
-
-    const spec = canonicalizeJson(getPColumnSpecId(linkerColumn.spec));
-    if (mainColumnsBySpec.has(spec)) continue;
-    if (secondaryColumnsBySpec.has(spec)) continue;
-
-    mainColumnsIds.add(linkerColumn.id);
-    mainColumnsBySpec.set(spec, linkerColumn);
-  }
-
-  return [...mainColumnsBySpec.values(), ...secondaryColumnsBySpec.values()];
+  return [column, ...additionalColumns];
 }
 
 export function createPFrameForGraphs<A, U>(
   ctx: RenderCtx<A, U>,
-  blockColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues>[] | undefined,
+  blockColumns: PColumn<PColumnDataUniversal>[] | undefined,
 ): PFrameHandle | undefined {
   if (!blockColumns) return undefined;
 
-  const upstreamColumns = ctx.resultPool
-    .getData()
-    .entries.map((v) => v.obj)
-    .filter(isPColumn);
+  const columns = new PColumnCollection();
+  columns.addColumnProvider(ctx.resultPool);
+  columns.addColumns(blockColumns);
+
+  // all possible axes from block columns
+  const allAxes = new Map<CanonicalizedJson<AxisId>, AxisId>();
+  for (const c of blockColumns) {
+    for (const id of c.spec.axesSpec) {
+      const aid = getAxisId(id);
+      allAxes.set(canonicalizeJson(aid), aid);
+    }
+  }
 
-  const allAvailableColumns = [...blockColumns, ...upstreamColumns];
   // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
-  const linkerColumns = allAvailableColumns.filter((col) => isLinkerColumn(col.spec));
+  const linkerColumns = columns.getColumns((spec) => isLinkerColumn(spec)) ?? [];
+  const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, allAxes);
+  const labelColumns = columns.getColumns(isLabelColumn) ?? [];
 
-  const linkerColumnsMap = getLinkerColumnsMap(linkerColumns);
-  const columnsWithCompatibleFromUpstream = enrichColumnsWithCompatible(blockColumns, upstreamColumns, linkerColumns, linkerColumnsMap);
+  // all possible axes from connected linkers
+  for (const item of availableWithLinkersAxes) {
+    allAxes.set(...item);
+  }
+
+  let compatible = (columns.getColumns([...allAxes.values()]
+    .map((ax) => ({
+      axes: [ax],
+      partialAxesMatch: true,
+    }))) ?? []).filter((column) => !isLabelColumn(column.spec));
+  compatible = compatible.concat(labelColumns); // add all available labels columns to avoid problems with fixed axes, but don't add twice
 
-  // additional columns are duplicates with extra fields in domains for compatibility in all possible pairs of columns set
-  // const extendedColumns = [...columnsWithCompatibleFromUpstream, ...getAdditionalColumns(columnsWithCompatibleFromUpstream, linkerColumnsMap)];
-  const extendedColumns = [...columnsWithCompatibleFromUpstream];
+  // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
+  const extendedColumns = enrichCompatible(allAxes, compatible);
 
   // if at least one column is not yet ready, we can't show the table
   if (

package/src/components/PlDataTable.ts

@@ -28,6 +28,7 @@ import {
 import type {
   AxisLabelProvider,
   ColumnProvider,
+  PColumnDataUniversal,
   RenderCtx,
 } from '../render';
 import {
@@ -363,7 +364,7 @@ export function isLabelColumn(column: PColumnSpec) {
 /** Get all label columns from the result pool */
 export function getAllLabelColumns(
   resultPool: AxisLabelProvider & ColumnProvider,
-): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] | undefined {
+): PColumn<PColumnDataUniversal>[] | undefined {
   return new PColumnCollection()
     .addAxisLabelProvider(resultPool)
     .addColumnProvider(resultPool)
@@ -376,8 +377,8 @@ export function getAllLabelColumns(
 /** Get label columns matching the provided columns from the result pool */
 export function getMatchingLabelColumns(
   columns: PColumnIdAndSpec[],
-  allLabelColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[],
-): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] {
+  allLabelColumns: PColumn<PColumnDataUniversal>[],
+): PColumn<PColumnDataUniversal>[] {
   // split input columns into label and value columns
   const inputLabelColumns: typeof columns = [];
   const inputValueColumns: typeof columns = [];
@@ -485,8 +486,8 @@ export function allColumnsComputed(
 }
 
 function createPTableDef(
-  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
-  labelColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[],
+  columns: PColumn<PColumnDataUniversal>[],
+  labelColumns: PColumn<PColumnDataUniversal>[],
   coreJoinType: 'inner' | 'full',
   filters: PTableRecordSingleValueFilterV2[],
   sorting: PTableSorting[],

package/src/render/api.ts

@@ -51,6 +51,8 @@ import type { LabelDerivationOps } from './util/label';
 import { deriveLabels } from './util/label';
 import type { APColumnSelectorWithSplit } from './util/split_selectors';
 
+export type PColumnDataUniversal = TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues;
+
 /**
  * Helper function to match domain objects
  * @param query Optional domain to match against
@@ -73,7 +75,7 @@ export type UniversalColumnOption = { label: string; value: SUniversalPColumnId
  * @param data Data from a PColumn to transform
  * @returns Transformed data compatible with platform API
  */
-function transformPColumnData(data: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>):
+function transformPColumnData(data: PColumn<PColumnDataUniversal>):
 PColumn<PColumnValues | AccessorHandle | DataInfo<AccessorHandle>> {
   return mapPObjectData(data, (d) => {
     if (d instanceof TreeNodeAccessor) {
@@ -191,7 +193,7 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
     anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,
     predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[],
     opts?: UniversalPColumnOpts,
-  ): PColumn<DataInfo<TreeNodeAccessor> | TreeNodeAccessor>[] | undefined {
+  ): PColumn<PColumnDataUniversal>[] | undefined {
     const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
     if (!anchorCtx) return undefined;
     return new PColumnCollection()
@@ -565,7 +567,7 @@ export class RenderCtx<Args, UiState> {
     return this.resultPool.findLabels(axis);
   }
 
-  private verifyInlineAndExplicitColumnsSupport(columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[]) {
+  private verifyInlineAndExplicitColumnsSupport(columns: PColumn<PColumnDataUniversal>[]) {
     const hasInlineColumns = columns.some((c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data)); // Updated check for DataInfo
     const inlineColumnsSupport = this.ctx.featureFlags?.inlineColumnsSupport === true;
     if (hasInlineColumns && !inlineColumnsSupport) throw Error(`Inline or explicit columns not supported`); // Combined check
@@ -574,7 +576,7 @@ export class RenderCtx<Args, UiState> {
   }
 
   // TODO remove all non-PColumn fields
-  public createPFrame(def: PFrameDef<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>): PFrameHandle {
+  public createPFrame(def: PFrameDef<PColumnDataUniversal>): PFrameHandle {
     this.verifyInlineAndExplicitColumnsSupport(def);
     return this.ctx.createPFrame(
       def.map((c) => transformPColumnData(c)),
@@ -582,24 +584,24 @@ export class RenderCtx<Args, UiState> {
   }
 
   // TODO remove all non-PColumn fields
-  public createPTable(def: PTableDef<PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>>): PTableHandle;
+  public createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle;
   public createPTable(def: {
-    columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[];
+    columns: PColumn<PColumnDataUniversal>[];
     filters?: PTableRecordFilter[];
     /** Table sorting */
     sorting?: PTableSorting[];
   }): PTableHandle;
   public createPTable(
     def:
-      | PTableDef<PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>>
+      | PTableDef<PColumn<PColumnDataUniversal>>
       | {
-        columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[];
+        columns: PColumn<PColumnDataUniversal>[];
         filters?: PTableRecordFilter[];
         /** Table sorting */
         sorting?: PTableSorting[];
       },
   ): PTableHandle {
-    let rawDef: PTableDef<PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>>;
+    let rawDef: PTableDef<PColumn<PColumnDataUniversal>>;
     if ('columns' in def) {
       rawDef = {
         src: {

package/src/render/util/column_collection.ts

@@ -1,7 +1,6 @@
 import type {
   AnchoredIdDeriver,
   AxisId,
-  DataInfo,
   PColumn,
   PColumnSelector,
   PColumnSpec,
@@ -13,6 +12,7 @@ import type {
   PartitionedDataInfoEntries,
   ResolveAnchorsOptions,
   NativePObjectId,
+  PColumnValues,
 } from '@milaboratories/pl-model-common';
 import {
   selectorsToPredicate,
@@ -32,9 +32,17 @@ import type { APColumnSelectorWithSplit, PColumnSelectorWithSplit } from './spli
 import canonicalize from 'canonicalize';
 import { getUniquePartitionKeys, convertOrParsePColumnData } from './pcolumn_data';
 import { filterDataInfoEntries } from './axis_filtering';
+import type { PColumnDataUniversal } from '../api';
+
+function isPColumnValues(value: unknown): value is PColumnValues {
+  if (!Array.isArray(value)) return false;
+  if (value.length === 0) return true;
+  const first = value[0];
+  return typeof first === 'object' && first !== null && 'key' in first && 'val' in first;
+}
 
 export interface ColumnProvider {
-  selectColumns(selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[]): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[];
+  selectColumns(selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[]): PColumn<PColumnDataUniversal | undefined>[];
 }
 
 export interface AxisLabelProvider {
@@ -45,13 +53,13 @@ export interface AxisLabelProvider {
  * A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
  */
 class ArrayColumnProvider implements ColumnProvider {
-  constructor(private readonly columns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[]) {}
+  constructor(private readonly columns: PColumn<PColumnDataUniversal | undefined>[]) {}
 
   selectColumns(selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[]):
-  PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[] {
+  PColumn<PColumnDataUniversal | undefined>[] {
     const predicate = typeof selectors === 'function' ? selectors : selectorsToPredicate(selectors);
     // Filter based on spec, ignoring data type for now
-    return this.columns.filter((column): column is PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined> => predicate(column.spec));
+    return this.columns.filter((column): column is PColumn<PColumnDataUniversal | undefined> => predicate(column.spec));
   }
 }
 
@@ -59,7 +67,7 @@ export type PColumnEntryWithLabel = {
   id: PObjectId;
   spec: PColumnSpec;
   /** Lazy calculates the data, returns undefined if data is not ready. */
-  data(): DataInfo<TreeNodeAccessor> | TreeNodeAccessor | undefined;
+  data(): PColumnDataUniversal | undefined;
   label: string;
 };
 
@@ -79,7 +87,7 @@ type AxisFilterInfo = {
 // Intermediate representation for columns requiring splitting
 type IntermediateSplitEntry = {
   type: 'split';
-  originalColumn: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>;
+  originalColumn: PColumn<PColumnDataUniversal | undefined>;
   spec: PColumnSpec;
   /** With splitting axes removed */
   adjustedSpec: PColumnSpec;
@@ -90,7 +98,7 @@ type IntermediateSplitEntry = {
 // Intermediate representation for columns NOT requiring splitting
 type IntermediateDirectEntry = {
   type: 'direct';
-  originalColumn: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>;
+  originalColumn: PColumn<PColumnDataUniversal | undefined>;
   spec: PColumnSpec;
   /** The same as `spec` */
   adjustedSpec: PColumnSpec;
@@ -169,7 +177,7 @@ type UniversalPColumnOpts = UniversalPColumnOptsNoDeriver & {
 } & ResolveAnchorsOptions;
 
 export class PColumnCollection {
-  private readonly defaultProviderStore: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[] = [];
+  private readonly defaultProviderStore: PColumn<PColumnDataUniversal | undefined>[] = [];
   private readonly providers: ColumnProvider[] = [new ArrayColumnProvider(this.defaultProviderStore)];
   private readonly axisLabelProviders: AxisLabelProvider[] = [];
 
@@ -185,12 +193,12 @@ export class PColumnCollection {
     return this;
   }
 
-  public addColumns(columns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[]): this {
+  public addColumns(columns: PColumn<PColumnDataUniversal | undefined>[]): this {
     this.defaultProviderStore.push(...columns);
     return this;
   }
 
-  public addColumn(column: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>): this {
+  public addColumn(column: PColumn<PColumnDataUniversal | undefined>): this {
     this.defaultProviderStore.push(column);
     return this;
   }
@@ -256,7 +264,7 @@ export class PColumnCollection {
         currentSelector = rawSelector as PColumnSelectorWithSplit | ((spec: PColumnSpec) => boolean);
 
       const selectedIds = new Set<PObjectId>();
-      const selectedColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor> | undefined>[] = [];
+      const selectedColumns: PColumn<PColumnDataUniversal | undefined>[] = [];
       for (const provider of this.providers) {
         const providerColumns = provider.selectColumns(currentSelector);
         for (const col of providerColumns) {
@@ -283,6 +291,8 @@ export class PColumnCollection {
         const originalSpec = column.spec;
 
         if (needsSplitting) {
+          if (isPColumnValues(column.data))
+            throw new Error(`Splitting is not supported for PColumns with PColumnValues data format. Column id: ${column.id}`);
           const dataEntries = convertOrParsePColumnData(column.data);
 
           if (!dataEntries) {
@@ -417,20 +427,20 @@ export class PColumnCollection {
 
   public getColumns(
     predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[],
-    opts: UniversalPColumnOpts): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] | undefined;
+    opts: UniversalPColumnOpts): PColumn<PColumnDataUniversal>[] | undefined;
   public getColumns(
     predicateOrSelectors: ((spec: PColumnSpec) => boolean) | PColumnSelectorWithSplit | PColumnSelectorWithSplit[],
-    opts?: UniversalPColumnOptsNoDeriver): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] | undefined;
+    opts?: UniversalPColumnOptsNoDeriver): PColumn<PColumnDataUniversal>[] | undefined;
   public getColumns(
     predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[],
-    opts?: Optional<UniversalPColumnOpts, 'anchorCtx'>): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] | undefined {
+    opts?: Optional<UniversalPColumnOpts, 'anchorCtx'>): PColumn<PColumnDataUniversal>[] | undefined {
     const entries = this.getUniversalEntries(predicateOrSelectors, {
       overrideLabelAnnotation: true, // default for getColumns
       ...(opts ?? {}),
     } as UniversalPColumnOpts);
     if (!entries) return undefined;
 
-    const columns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] = [];
+    const columns: PColumn<PColumnDataUniversal>[] = [];
     for (const entry of entries) {
       const data = entry.data();
       if (!data) {