@platforma-sdk/model 1.79.27 → 1.80.2

package/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js

@@ -1,162 +1,204 @@
-import { collectFilterSpecColumns, traverseFilterSpec } from "../../../filters/traverse.js";
+import { collectLinkerColumns, hitQualifications, isLeafColumn, queriesQualifications } from "../../../columns/utils.js";
+import "../../../columns/index.js";
+import { collectFilterSpecColumns } from "../../../filters/traverse.js";
 import { upgradePlDataTableStateV2 } from "../state-migration.js";
 import { createPTableDefV3 } from "./createPTableDefV3.js";
-import { deriveAllLabels, deriveAllTooltips, evaluateRules, isColumnHidden, isColumnOptional, withDataStatusAnnotations, withHidenAxesAnnotations, withInfoAnnotations, withLabelAnnotations, withTableVisualAnnotations } from "./utils.js";
-import { discoverLabelColumnVariants, discoverTableColumnSnaphots } from "./discoverColumns.js";
-import { canonicalizeJson, getAxisId, parseJson, uniqueBy } from "@milaboratories/pl-model-common";
-import { getField, isNil, isPlainObject, throwError } from "@milaboratories/helpers";
-import { flow } from "es-toolkit";
-import { isEmpty } from "es-toolkit/compat";
+import { buildDataStatusMap, deriveAllLabels, evaluateRules, getEffectiveVisibility, getOrderPriority, isColumnHidden, toRuleColumn } from "./utils.js";
+import { createColumnResolver } from "../columnResolver.js";
+import { discoverLabelColumns, discoverTableColumns } from "./discoverColumns.js";
+import { canonicalizeAxisId, dedupColumns, extractPObjectId, uniqueBy } from "@milaboratories/pl-model-common";
+import { isNil, isPlainObject } from "@milaboratories/helpers";
+import { uniq } from "es-toolkit";
 //#region src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts
 function createPlDataTableV3(ctx, options) {
-	const pframeSpec = ctx.getService("pframeSpec");
 	const state = upgradePlDataTableStateV2(options.tableState);
 	const primaryJoinType = options.primaryJoinType ?? "full";
-	const discovered = isPlainObject(options.columns) ? discoverTableColumnSnaphots(ctx, options.columns) : isNil(options.columns) ? options.columns : uniqueBy([...options.columns, ...discoverLabelColumnVariants(ctx, options.columns)], (c) => c.column.id);
-	if (isNil(discovered) || discovered.length === 0) return void 0;
-	const splited = splitDiscoveredColumns(discovered);
+	const resolved = resolveInputColumns(ctx, options);
+	if (resolved === void 0) return void 0;
+	const { primary, secondary } = resolved;
+	if (primary.length === 0) return void 0;
+	const { direct, linked } = splitByTopology(secondary);
 	const derivedLabels = deriveAllLabels({
-		columns: discovered.map((dc) => ({
-			id: dc.column.id,
-			spec: dc.column.spec,
-			linkerPath: dc.path,
-			qualifications: dc.qualifications
-		})).filter((v) => !isColumnHidden(v.spec)),
+		columns: [...primary, ...secondary].filter((c) => !isColumnHidden(c.getSpec())).map(toLabelableColumn),
 		deriveLabelsOptions: {
 			includeNativeLabel: true,
 			...options.labelsOptions
 		}
 	});
-	const derivedTooltips = deriveAllTooltips({ columns: discovered.map((dc) => ({
-		id: dc.column.id,
-		originalId: getField(dc, "originalId"),
-		spec: dc.column.spec,
-		linkerPath: dc.path,
-		qualifications: dc.qualifications
-	})) });
-	const annotated = annotateColumnGroups({
-		pframeSpec,
-		...splited,
-		derivedLabels,
-		derivedTooltips,
-		displayOptions: options.displayOptions
-	});
-	const primarySnapshots = annotated.direct.filter((c) => c.isPrimary);
-	const secondarySnapshots = annotated.direct.filter((c) => !c.isPrimary);
-	if (primarySnapshots.length === 0) return void 0;
-	const columnIsAvailable = createColumnValidationById([...annotated.direct.map((v) => v.column), ...annotated.linked.flatMap((lc) => [...(lc.path ?? []).map((s) => s.linker), lc.column])]);
-	const remapedDefaultFilters = remapFilterColumnIds(options.filters, discovered);
-	const filters = filterFilters(concatFilters(state.pTableParams.filters, state.pTableParams.defaultFilters ?? remapedDefaultFilters), columnIsAvailable);
-	const sorting = filterSorting(resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, discovered)), columnIsAvailable);
-	const primaryEntries = primarySnapshots.map((v) => ({ column: resolveSnapshot(v.column) }));
+	const allColumnsForRules = [
+		...primary,
+		...direct,
+		...linked,
+		...collectLinkerSnapshots(linked)
+	];
+	const visibilityByColId = evaluateRules(options.displayOptions?.visibility ?? [], allColumnsForRules);
+	const orderByColId = evaluateRules(options.displayOptions?.ordering ?? [], allColumnsForRules);
+	const resolver = createColumnResolver([
+		...primary,
+		...direct,
+		...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc])
+	], { warn: ctx.logWarn.bind(ctx) });
+	const remapedDefaultFilters = remapFilterColumnIds(options.filters, resolver);
+	const filters = filterFilters(concatFilters(state.pTableParams.filters, state.pTableParams.defaultFilters ?? remapedDefaultFilters), resolver);
+	const sorting = filterSorting(resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, resolver)), resolver);
 	const fullDef = createPTableDefV3({
 		primaryJoinType,
-		primary: primaryEntries,
-		secondary: buildSecondaryGroups(secondarySnapshots, annotated.linked),
+		primary,
+		secondary: [...direct, ...linked],
 		filters,
 		sorting
 	});
 	const fullHandle = ctx.createPTableV2(fullDef);
-	const pframeHandle = ctx.createPFrame([
-		...annotated.direct.map((v) => resolveSnapshot(v.column)),
-		...annotated.linked.map((v) => resolveSnapshot(v.column)),
-		...collectLinkerSnapshots(annotated.linked).map(resolveSnapshot)
-	]);
+	const pframeHandle = ctx.createPFrame(uniq([
+		...primary.map((v) => extractPObjectId(v.id)),
+		...direct.map((v) => extractPObjectId(v.id)),
+		...linked.map((v) => extractPObjectId(v.id))
+	]));
 	const hiddenSpecs = state.pTableParams.hiddenColIds;
-	const visible = buildVisibleColumns(annotated, computeHiddenColumns([...annotated.direct, ...annotated.linked].map((v) => v.column), sorting, filters, hiddenSpecs));
+	const hiddenColumnIds = computeHiddenColumns({
+		columns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibilityByColId,
+		sorting,
+		filters,
+		hiddenSpecs
+	});
+	const visible = {
+		primary,
+		direct: direct.filter((c) => !hiddenColumnIds.has(c.id)),
+		linked: linked.filter((c) => !hiddenColumnIds.has(c.id))
+	};
 	const visibleDef = createPTableDefV3({
 		primaryJoinType,
-		primary: primaryEntries,
-		secondary: buildSecondaryGroups(visible.direct.filter((c) => !c.isPrimary), visible.linked),
+		primary,
+		secondary: [...visible.direct, ...visible.linked],
 		filters,
 		sorting
 	});
 	const visibleHandle = ctx.createPTableV2(visibleDef);
+	const columnsMeta = buildColumnsMeta({
+		fullColumns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibleColumns: [
+			...visible.primary,
+			...visible.direct,
+			...visible.linked
+		],
+		primaryColumns: primary,
+		derivedLabels,
+		visibilityByColId,
+		orderByColId
+	});
 	return {
 		sourceId: state.pTableParams.sourceId,
 		fullTableHandle: fullHandle,
 		fullPframeHandle: pframeHandle,
 		visibleTableHandle: visibleHandle,
-		defaultFilters: remapedDefaultFilters
+		defaultFilters: remapedDefaultFilters,
+		columnsMeta
 	};
 }
-/** Split discovered columns into direct (no linker path) and linked (with linker path). */
-function splitDiscoveredColumns(columns) {
+/** Normalize either option branch into a {primary, secondary} pair of recipes. */
+function resolveInputColumns(ctx, options) {
+	if ("primaryColumns" in options) {
+		const primary = options.primaryColumns;
+		const secondary = options.columns ?? [];
+		const labels = discoverLabelColumns(ctx, primary, [...primary, ...secondary]);
+		const primaryIds = new Set(primary.map((c) => c.id));
+		return {
+			primary,
+			secondary: dedupColumns([...secondary, ...labels].filter((c) => !primaryIds.has(c.id)), (c) => c.id, (c) => c.getSpec())
+		};
+	}
+	if (isPlainObject(options.columns)) return discoverTableColumns(ctx, options.columns);
+}
+/** Split secondary recipes by query topology: leaves (no linker chain) vs joined. */
+function splitByTopology(columns) {
+	const direct = [];
+	const linked = [];
+	for (const c of columns) if (isLeafColumn(c)) direct.push(c);
+	else linked.push(c);
 	return {
-		direct: columns.filter((dc) => (dc.path?.length ?? 0) === 0),
-		linked: columns.filter((dc) => (dc.path?.length ?? 0) > 0)
+		direct,
+		linked
 	};
 }
-/** All linker snapshots across the given linked columns, deduped by id. */
+/** All linker recipes across the given linked columns, deduped by id. */
 function collectLinkerSnapshots(linked) {
-	return uniqueBy(linked.flatMap((lc) => (lc.path ?? []).map((s) => s.linker)), (c) => c.id);
+	return uniqueBy(linked.flatMap((c) => collectLinkerColumns(c)), (c) => c.id);
 }
-/**
-* Annotate all column groups with derived labels and display-rule annotations.
-* Evaluates `displayOptions` rules against all discovered columns (direct,
-* linked, labels, linkers) and writes the winning visibility/priority into
-* column annotations via `withTableVisualAnnotations`.
-*/
-function annotateColumnGroups(params) {
-	const { direct, linked, derivedLabels, derivedTooltips, displayOptions, pframeSpec } = params;
-	const allColumnsForRules = [
-		...direct.map((v) => v.column),
-		...linked.map((v) => v.column),
-		...collectLinkerSnapshots(linked)
-	];
-	const visibilityByColId = evaluateRules(displayOptions?.visibility ?? [], allColumnsForRules, pframeSpec);
-	const orderByColId = evaluateRules(displayOptions?.ordering ?? [], allColumnsForRules, pframeSpec);
+function toLabelableColumn(col) {
 	return {
-		direct: liftToVariantColumns(direct, flow((cols) => withDataStatusAnnotations(cols), (cols) => withLabelAnnotations(derivedLabels, cols), (cols) => withInfoAnnotations(derivedTooltips, cols), (cols) => withTableVisualAnnotations(visibilityByColId, orderByColId, cols))),
-		linked: liftToVariantColumns(linked, flow((cols) => withDataStatusAnnotations(cols), (cols) => withHidenAxesAnnotations(cols), (cols) => withLabelAnnotations(derivedLabels, cols), (cols) => withInfoAnnotations(derivedTooltips, cols), (cols) => withTableVisualAnnotations(visibilityByColId, orderByColId, cols))).map((lc) => ({
-			...lc,
-			path: annotateLinkerPath(derivedLabels, lc.path)
-		}))
+		id: col.id,
+		spec: col.getSpec(),
+		linkerPath: collectLinkerColumns(col).map((linker) => ({ linker: { spec: linker.getSpec() } })),
+		qualifications: {
+			forHit: [...hitQualifications(col)],
+			forQueries: queriesQualifications(col)
+		}
 	};
 }
-/** Lift a snapshot-array transform so it runs on the inner `column` of each variant. */
-function liftToVariantColumns(variants, fn) {
-	const cols = fn(variants.map((v) => v.column));
-	if (cols.length !== variants.length) throw new Error(`liftToVariantColumns: fn must preserve array length (got ${cols.length}, expected ${variants.length})`);
-	return variants.map((v, i) => ({
-		...v,
-		column: cols[i]
-	}));
-}
-function annotateLinkerPath(derivedLabels, path) {
-	if (isNil(path) || path.length === 0) return path;
-	const annotatedLinkers = withHidenAxesAnnotations(withLabelAnnotations(derivedLabels, path.map((s) => s.linker)));
-	return path.map((s, i) => ({
-		...s,
-		linker: annotatedLinkers[i]
-	}));
-}
-/** Build an index of all valid column IDs (axes + columns) for filter/sorting validation. */
-function createColumnValidationById(fullColumns) {
-	const allIds = [...uniqueBy(fullColumns.flatMap((c) => c.spec.axesSpec.map(getAxisId)), (a) => canonicalizeJson(a)).map((a) => ({
-		type: "axis",
-		id: a
-	})), ...fullColumns.map((c) => ({
-		type: "column",
-		id: c.id
-	}))];
-	const validIdSet = new Set(allIds.map((c) => canonicalizeJson(c)));
-	return (id) => {
-		return validIdSet.has(id);
+/**
+* Compute display metadata as a sidecar keyed by each emitted column's
+* `ColumnUniversalId` (and axis `AxisId`), instead of baking it into the specs
+* via `withSpecs`. Spec overrides change a recipe's id, so the same physical
+* column reached two ways would diverge into two ids and render twice; keeping
+* meta out of the spec preserves identity and lets dedup collapse such cases.
+* The UI overlays this onto the engine-emitted specs at render time.
+*/
+function buildColumnsMeta(params) {
+	const { fullColumns, visibleColumns, primaryColumns, derivedLabels } = params;
+	const { visibilityByColId, orderByColId } = params;
+	const visibleStatus = buildDataStatusMap(visibleColumns);
+	const columns = fullColumns.reduce((acc, c) => {
+		const rc = toRuleColumn(c);
+		acc[c.id] = {
+			label: derivedLabels[c.id],
+			visibility: getEffectiveVisibility(rc, visibilityByColId),
+			order: getOrderPriority(rc, orderByColId),
+			status: visibleStatus[c.id]
+		};
+		return acc;
+	}, {});
+	const primaryAxisKeys = new Set(primaryColumns.flatMap((c) => c.getSpec().axesSpec.map((a) => canonicalizeAxisId(a))));
+	return {
+		columns,
+		axes: fullColumns.reduce((acc, c) => c.getSpec().axesSpec.reduce((inner, ax) => {
+			const key = canonicalizeAxisId(ax);
+			if (inner[key] === void 0) inner[key] = { hidden: !primaryAxisKeys.has(key) };
+			return inner;
+		}, acc), {})
 	};
 }
-/** Drop filter leaves whose column references are not available in the table. */
-function filterFilters(filters, isValidColumnId) {
+/** Drop filter leaves whose column references cannot be resolved; rewrite the
+*  resolvable ones through the resolver. Prune empty and/or/not groups. */
+function filterFilters(filters, resolver) {
 	if (isNil(filters)) return filters;
-	const isLeafValid = (leaf) => {
-		if (leaf.type === void 0) return true;
-		if ("column" in leaf && !isValidColumnId(leaf.column)) return false;
-		if ("rhs" in leaf && !isValidColumnId(leaf.rhs)) return false;
-		return true;
+	const rewriteLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil(c)) return void 0;
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil(c)) return void 0;
+			result.rhs = c;
+		}
+		return result;
 	};
 	const prune = (node) => {
 		if (node.type === "and" || node.type === "or") {
 			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil(f));
+			if (kept.length === 0) return void 0;
 			return {
 				type: node.type,
 				filters: kept
@@ -169,7 +211,7 @@ function filterFilters(filters, isValidColumnId) {
 				filter: inner
 			};
 		}
-		return isLeafValid(node) ? node : void 0;
+		return rewriteLeaf(node);
 	};
 	return prune(filters);
 }
@@ -182,34 +224,30 @@ function concatFilters(a, b) {
 		filters: [...a.filters, ...b.filters]
 	};
 }
-/** Pick user sorting from state if non-empty, otherwise fall back to options default. */
+/** Pick user sorting from state if set, otherwise fall back to options default.
+*  null = user has not touched sorting → use default;
+*  [] = user has explicitly cleared sorting → no sorting (default ignored). */
 function resolveSorting(userSorting, defaultSorting) {
-	return (isEmpty(userSorting) ? defaultSorting : userSorting) ?? [];
+	return (isNil(userSorting) ? defaultSorting : userSorting) ?? [];
 }
-/** Drop sorting entries whose column is not available in the table. */
-function filterSorting(sorting, isValidColumnId) {
-	return sorting.filter((s) => isValidColumnId(canonicalizeJson(s.column)));
-}
-function buildSecondaryGroups(direct, linked) {
-	return [...direct.map((c) => ({
-		entries: [{
-			column: resolveSnapshot(c.column),
-			qualifications: c.qualifications?.forHit
-		}],
-		primaryQualifications: c.qualifications?.forQueries
-	})), ...linked.map((lc) => ({
-		entries: [{
-			column: resolveSnapshot(lc.column),
-			linkers: lc.path?.map((s) => resolveSnapshot(s.linker)),
-			qualifications: lc.qualifications?.forHit
-		}],
-		primaryQualifications: lc.qualifications?.forQueries
-	}))];
+/** Rewrite sorting entries through the resolver; drop those that fail to resolve. */
+function filterSorting(sorting, resolver) {
+	return sorting.flatMap((s) => {
+		const col = resolver(s.column);
+		return isNil(col) ? [] : [{
+			...s,
+			column: col
+		}];
+	});
 }
-/** Determine which columns should be hidden based on state or optional-column defaults. */
-function computeHiddenColumns(columns, sorting, filters, hiddenSpecs) {
-	const alwaysHidden = columns.filter((c) => isColumnHidden(c.spec)).map((c) => c.id);
-	const optionalHidden = !isNil(hiddenSpecs) ? hiddenSpecs.filter((s) => s.type === "column").map((s) => s.id) : columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
+/** Determine which columns should be hidden based on state or optional-column defaults.
+*  Keyed by the recipe's logical {@link ColumnUniversalId} (rich) — variants of
+*  the same physical column are independently visible/hidden. */
+function computeHiddenColumns(params) {
+	const { columns, visibilityByColId, sorting, filters, hiddenSpecs } = params;
+	const visibilityOf = (c) => getEffectiveVisibility(toRuleColumn(c), visibilityByColId);
+	const alwaysHidden = columns.filter((c) => visibilityOf(c) === "hidden").map((c) => c.id);
+	const optionalHidden = !isNil(hiddenSpecs) ? hiddenSpecs.filter((s) => s.type === "column").map((s) => s.id) : columns.filter((c) => visibilityOf(c) === "optional").map((c) => c.id);
 	const initial = [...alwaysHidden, ...optionalHidden];
 	const preserved = collectPreservedColumnIds(sorting, filters);
 	return new Set(initial.filter((id) => !preserved.has(id)));
@@ -217,76 +255,68 @@ function computeHiddenColumns(columns, sorting, filters, hiddenSpecs) {
 /** Collect IDs of columns that must remain visible (sorted, filtered). */
 function collectPreservedColumnIds(sorting, filters) {
 	const sortedIds = (sorting ?? []).map((s) => s.column).filter((c) => c.type === "column").map((c) => c.id);
-	const filterIds = !isNil(filters) ? collectFilterSpecColumns(filters).flatMap((c) => {
-		const obj = parseJson(c);
-		return obj.type === "column" ? [obj.id] : [];
-	}) : [];
+	const filterIds = !isNil(filters) ? collectFilterSpecColumns(filters).flatMap((c) => c.type === "column" ? [c.id] : []) : [];
 	return /* @__PURE__ */ new Set([...sortedIds, ...filterIds]);
 }
-/** Filter annotated columns to only visible ones, re-matching label columns for the visible subset. */
-function buildVisibleColumns(annotated, hiddenColumns) {
-	return {
-		direct: annotated.direct.filter((c) => !hiddenColumns.has(c.column.id)),
-		linked: annotated.linked.filter((c) => !hiddenColumns.has(c.column.id))
-	};
-}
-/** Resolve a ColumnSnapshot to a PColumn with lazily-evaluated data. */
-function resolveSnapshot(snap) {
-	return {
-		id: snap.id,
-		spec: snap.spec,
-		data: snap.data?.get()
-	};
-}
-/** Remap column references in sorting entries. */
-function remapSortingColumnIds(sorting, columns) {
+/** Remap column references in sorting entries through the resolver.
+*  Unresolved entries are dropped with a warning (best-effort contract). */
+function remapSortingColumnIds(sorting, resolver) {
 	return sorting?.flatMap((s) => {
-		if (s.column.type === "axis") return [s];
-		const id = s.column.id;
-		const column = columns.find((c) => (getField(c, "originalId") ?? c.column.id) === id);
-		if (column === void 0) return [];
+		const col = resolver(s.column);
+		if (isNil(col)) {
+			console.warn(`Sorting column ${JSON.stringify(s.column)} does not match any discovered column — dropped.`);
+			return [];
+		}
 		return [{
 			...s,
-			column: {
-				type: "column",
-				id: column.column.id
-			}
+			column: col
 		}];
 	});
 }
-/** Remap column references in a filter tree. */
-function remapFilterColumnIds(filters, columns) {
+/** Remap column references in a filter tree through the resolver.
+*  Unresolved leaves are dropped with a warning; empty groups are pruned. */
+function remapFilterColumnIds(filters, resolver) {
 	if (isNil(filters)) return filters;
-	const map = (tableColumnId) => {
-		const parsed = parseJson(tableColumnId);
-		if (parsed.type === "axis") return tableColumnId;
-		const originalId = parsed.id;
-		return canonicalizeJson({
-			type: "column",
-			id: (columns.find((c) => (getField(c, "originalId") ?? c.column.id) === originalId) ?? throwError(`Column ID "${parsed.id}" in filters does not match any discovered column`)).column.id
-		});
+	const mapLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil(c)) {
+				console.warn(`Filter column ${JSON.stringify(result.column)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil(c)) {
+				console.warn(`Filter rhs ${JSON.stringify(result.rhs)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.rhs = c;
+		}
+		return result;
 	};
-	return traverseFilterSpec(filters, {
-		leaf: (leaf) => {
-			if (leaf.type === void 0) return leaf;
-			const result = { ...leaf };
-			if ("column" in result) result.column = map(result.column);
-			if ("rhs" in result) result.rhs = map(result.rhs);
-			return result;
-		},
-		and: (results) => ({
-			type: "and",
-			filters: results
-		}),
-		or: (results) => ({
-			type: "or",
-			filters: results
-		}),
-		not: (result) => ({
-			type: "not",
-			filter: result
-		})
-	});
+	const prune = (node) => {
+		if (node.type === "and" || node.type === "or") {
+			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil(f));
+			if (kept.length === 0) return void 0;
+			return {
+				type: node.type,
+				filters: kept
+			};
+		}
+		if (node.type === "not") {
+			const inner = prune(node.filter);
+			return isNil(inner) ? void 0 : {
+				type: "not",
+				filter: inner
+			};
+		}
+		return mapLeaf(node);
+	};
+	return prune(filters);
 }
 //#endregion
 export { createPlDataTableV3 };