import type { PColumn, PColumnSpec, PFrameDef, PObjectId } from "@milaboratories/pl-model-common";
import {
getNormalizedAxesList,
getAxisId,
canonicalizeJson,
isLinkerColumn,
matchAxisId,
isLabelColumn,
extractPObjectId,
} from "@milaboratories/pl-model-common";
import type { AxesVault } from "./axes";
import { enrichCompatible, getAvailableWithLinkersAxes } from "./axes";
import type { RenderCtxBase, PColumnDataUniversal } from "../render";
import { PColumnCollection } from "../render";
import { ColumnsCollection } from "../columns";
export function getAllRelatedColumns(
ctx: RenderCtxBase,
predicate: (spec: PColumnSpec) => boolean,
): PFrameDef> {
// if current block doesn't produce own columns then use all columns from result pool
const columns = new PColumnCollection();
columns.addColumnProvider(ctx.resultPool);
const allColumns =
columns.getColumns(predicate, {
dontWaitAllData: true,
overrideLabelAnnotation: false,
}) ?? [];
const allAxes: AxesVault = new Map(
allColumns
.flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
.map((axisSpec) => {
const axisId = getAxisId(axisSpec);
return [canonicalizeJson(axisId), axisSpec];
}),
);
// additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
const extendedColumns = enrichCompatible(allAxes, allColumns);
return extendedColumns;
}
export function getRelatedColumns(
ctx: RenderCtxBase,
{
columns: rootColumns,
predicate,
}: {
columns: PColumn[];
predicate: (spec: PColumnSpec) => boolean;
},
): PFrameDef> {
// if current block has its own columns then take from result pool only compatible with them
const columns = new PColumnCollection();
columns.addColumnProvider(ctx.resultPool);
columns.addColumns(rootColumns);
// all possible axes from block columns
const blockAxes: AxesVault = new Map();
// axes from block columns and compatible result pool columns
const allAxes: AxesVault = new Map();
for (const c of rootColumns) {
for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
const aid = getAxisId(spec);
blockAxes.set(canonicalizeJson(aid), spec);
allAxes.set(canonicalizeJson(aid), spec);
}
}
// all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
const linkerColumns =
columns.getColumns((spec) => predicate(spec) && isLinkerColumn(spec), {
dontWaitAllData: true,
}) ?? [];
const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
// all possible axes from connected linkers
for (const item of availableWithLinkersAxes) {
blockAxes.set(...item);
allAxes.set(...item);
}
const blockAxesArr = Array.from(blockAxes.values());
// all compatible with block columns but without label columns
let compatibleWithoutLabels = (
columns.getColumns(
(spec) =>
predicate(spec) &&
spec.axesSpec.some((axisSpec) => {
const axisId = getAxisId(axisSpec);
return blockAxesArr.some((selectorAxisSpec) =>
matchAxisId(getAxisId(selectorAxisSpec), axisId),
);
}),
{ dontWaitAllData: true, overrideLabelAnnotation: false },
) ?? []
).filter((column) => !isLabelColumn(column.spec));
// extend axes set for label columns request
for (const c of compatibleWithoutLabels) {
for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
const aid = getAxisId(spec);
allAxes.set(canonicalizeJson(aid), spec);
}
}
const allAxesArr = Array.from(allAxes.values());
// extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
compatibleWithoutLabels = (
columns.getColumns(
(spec) =>
predicate(spec) &&
spec.axesSpec.every((axisSpec) => {
const axisId = getAxisId(axisSpec);
return allAxesArr.some((selectorAxisSpec) =>
matchAxisId(getAxisId(selectorAxisSpec), axisId),
);
}),
{ dontWaitAllData: true, overrideLabelAnnotation: false },
) ?? []
).filter((column) => !isLabelColumn(column.spec));
// label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
const compatibleLabels = (
columns.getColumns(
(spec) =>
predicate(spec) &&
spec.axesSpec.some((axisSpec) => {
const axisId = getAxisId(axisSpec);
return allAxesArr.some((selectorAxisSpec) =>
matchAxisId(getAxisId(selectorAxisSpec), axisId),
);
}),
{ dontWaitAllData: true, overrideLabelAnnotation: false },
) ?? []
).filter((column) => isLabelColumn(column.spec));
const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
// Drop result-pool columns that share an axis with the block but cannot join it.
const integrableIds = discoverIntegrableColumnIds(ctx, rootColumns);
const rootIds = new Set(rootColumns.map((c) => c.id));
const connected = compatible.filter(
(c) => rootIds.has(c.id) || isLinkerColumn(c.spec) || (integrableIds?.has(c.id) ?? true),
);
// additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
const extendedColumns = enrichCompatible(blockAxes, connected);
return extendedColumns;
}
/** Column ids that discovery confirms integrate with the block, or `undefined` when it can't decide. */
function discoverIntegrableColumnIds(
ctx: RenderCtxBase,
rootColumns: PColumn[],
): Set | undefined {
const anchorSpecs = Array.from(
new Map(rootColumns.map((c) => [canonicalizeJson(c.spec), c.spec])).values(),
);
if (anchorSpecs.length === 0) return undefined;
try {
const columns = ColumnsCollection(undefined, { ctx: ctx.ctx })
.discover({
mode: "enrichment",
maxHops: 4,
anchors: Object.fromEntries(anchorSpecs.map((spec, i) => [`anchor_${i}`, spec])),
})
.getColumns();
return new Set(columns.map((c) => extractPObjectId(c.id)));
} catch {
return undefined;
}
}