@platforma-sdk/model 1.58.5 → 1.58.11

package/dist/render/util/column_collection.cjs

@@ -1,339 +1,284 @@
-'use strict';
-
-var plModelCommon = require('@milaboratories/pl-model-common');
-var canonicalize = require('canonicalize');
-var axis_filtering = require('./axis_filtering.cjs');
-var label = require('./label.cjs');
-var pcolumn_data = require('./pcolumn_data.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+const require_axis_filtering = require('./axis_filtering.cjs');
+const require_label = require('./label.cjs');
+const require_pcolumn_data = require('./pcolumn_data.cjs');
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+let canonicalize = require("canonicalize");
+canonicalize = require_runtime.__toESM(canonicalize);
 
+//#region src/render/util/column_collection.ts
 function isPColumnValues(value) {
-    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;
+	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;
 }
 /**
- * A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
- */
-class ArrayColumnProvider {
-    columns;
-    constructor(columns) {
-        this.columns = columns;
-    }
-    selectColumns(selectors) {
-        const predicate = typeof selectors === "function" ? selectors : plModelCommon.selectorsToPredicate(selectors);
-        // Filter based on spec, ignoring data type for now
-        return this.columns.filter((column) => predicate(column.spec));
-    }
-}
+* A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
+*/
+var ArrayColumnProvider = class {
+	constructor(columns) {
+		this.columns = columns;
+	}
+	selectColumns(selectors) {
+		const predicate = typeof selectors === "function" ? selectors : (0, _milaboratories_pl_model_common.selectorsToPredicate)(selectors);
+		return this.columns.filter((column) => predicate(column.spec));
+	}
+};
 function splitFiltersToTrace(splitFilters) {
-    if (!splitFilters)
-        return undefined;
-    return splitFilters.map((filter) => ({
-        type: `split:${plModelCommon.canonicalizeAxisId(filter.axisId)}`,
-        label: filter.label,
-        importance: 1_000_000, // High importance for split filters in labels
-    }));
+	if (!splitFilters) return void 0;
+	return splitFilters.map((filter) => ({
+		type: `split:${(0, _milaboratories_pl_model_common.canonicalizeAxisId)(filter.axisId)}`,
+		label: filter.label,
+		importance: 1e6
+	}));
 }
 function splitFiltersToAxisFilter(splitFilters) {
-    if (!splitFilters)
-        return undefined;
-    return splitFilters.map((filter) => [filter.axisIdx, filter.value]);
+	if (!splitFilters) return void 0;
+	return splitFilters.map((filter) => [filter.axisIdx, filter.value]);
 }
 function fallbackIdDeriver(originalId, axisFilters) {
-    if (!axisFilters || axisFilters.length === 0)
-        return originalId;
-    const filtersToCanonicalize = [...axisFilters].sort((a, b) => a[0] - b[0]);
-    return canonicalize({ id: originalId, axisFilters: filtersToCanonicalize });
+	if (!axisFilters || axisFilters.length === 0) return originalId;
+	return (0, canonicalize.default)({
+		id: originalId,
+		axisFilters: [...axisFilters].sort((a, b) => a[0] - b[0])
+	});
 }
 /** Checks if a selector object uses any anchor properties */
 function hasAnchors(selector) {
-    if (!selector || typeof selector !== "object")
-        return false;
-    const potentialAnchored = selector;
-    const domainHasAnchors = potentialAnchored["domain"] &&
-        typeof potentialAnchored["domain"] === "object" &&
-        Object.values(potentialAnchored["domain"]).some((v) => typeof v === "object" && v !== null && "anchor" in v);
-    const axesHaveAnchors = potentialAnchored["axes"] &&
-        Array.isArray(potentialAnchored["axes"]) &&
-        potentialAnchored["axes"].some((a) => typeof a === "object" && a !== null && "anchor" in a);
-    return !!potentialAnchored["domainAnchor"] || domainHasAnchors || axesHaveAnchors;
+	if (!selector || typeof selector !== "object") return false;
+	const potentialAnchored = selector;
+	const domainHasAnchors = potentialAnchored["domain"] && typeof potentialAnchored["domain"] === "object" && Object.values(potentialAnchored["domain"]).some((v) => typeof v === "object" && v !== null && "anchor" in v);
+	const axesHaveAnchors = potentialAnchored["axes"] && Array.isArray(potentialAnchored["axes"]) && potentialAnchored["axes"].some((a) => typeof a === "object" && a !== null && "anchor" in a);
+	return !!potentialAnchored["domainAnchor"] || domainHasAnchors || axesHaveAnchors;
 }
 /**
- * Derives the indices of axes marked for splitting based on the selector.
- * Throws an error if splitting is requested alongside `partialAxesMatch`.
- */
+* Derives the indices of axes marked for splitting based on the selector.
+* Throws an error if splitting is requested alongside `partialAxesMatch`.
+*/
 function getSplitAxisIndices(selector) {
-    if (typeof selector !== "object" || !("axes" in selector) || selector.axes === undefined) {
-        return []; // No axes specified or not an object selector, no splitting
-    }
-    const splitIndices = selector.axes
-        .map((axis, index) => typeof axis === "object" && "split" in axis && axis.split === true ? index : -1)
-        .filter((index) => index !== -1);
-    if (splitIndices.length > 0 && selector.partialAxesMatch !== undefined) {
-        throw new Error("Axis splitting is not supported when `partialAxesMatch` is defined.");
-    }
-    splitIndices.sort((a, b) => a - b);
-    return splitIndices;
-}
-class PColumnCollection {
-    defaultProviderStore = [];
-    providers = [
-        new ArrayColumnProvider(this.defaultProviderStore),
-    ];
-    axisLabelProviders = [];
-    constructor() { }
-    addColumnProvider(provider) {
-        this.providers.push(provider);
-        return this;
-    }
-    addAxisLabelProvider(provider) {
-        this.axisLabelProviders.push(provider);
-        return this;
-    }
-    addColumns(columns) {
-        this.defaultProviderStore.push(...columns);
-        return this;
-    }
-    addColumn(column) {
-        this.defaultProviderStore.push(column);
-        return this;
-    }
-    /** Fetches labels for a given axis from the registered providers */
-    findLabels(axis) {
-        for (const provider of this.axisLabelProviders) {
-            const labels = provider.findLabels(axis);
-            if (labels)
-                return labels; // First provider wins
-        }
-        return undefined;
-    }
-    getUniversalEntries(predicateOrSelectors, opts) {
-        const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude, enrichByLinkers = false, } = opts ?? {};
-        const labelOps = {
-            ...(overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false
-                ? { includeNativeLabel: true }
-                : {}),
-            ...rawLabelOps,
-        };
-        let excludePredicate = () => false;
-        if (exclude) {
-            const excludePredicartes = (Array.isArray(exclude) ? exclude : [exclude]).map((selector) => {
-                if (hasAnchors(selector)) {
-                    if (!anchorCtx)
-                        throw new Error("Anchored selectors in exclude require an AnchoredIdDeriver to be provided in options.");
-                    return plModelCommon.selectorsToPredicate(plModelCommon.resolveAnchors(anchorCtx.anchors, selector, opts));
-                }
-                else
-                    return plModelCommon.selectorsToPredicate(selector);
-            });
-            excludePredicate = (spec) => excludePredicartes.some((predicate) => predicate(spec));
-        }
-        const selectorsArray = typeof predicateOrSelectors === "function"
-            ? [predicateOrSelectors]
-            : Array.isArray(predicateOrSelectors)
-                ? predicateOrSelectors
-                : [predicateOrSelectors];
-        const intermediateResults = [];
-        const selectedNativeIds = new Set();
-        for (const rawSelector of selectorsArray) {
-            const usesAnchors = hasAnchors(rawSelector);
-            let currentSelector;
-            if (usesAnchors) {
-                if (!anchorCtx)
-                    throw new Error("Anchored selectors require an AnchoredIdDeriver to be provided in options.");
-                currentSelector = plModelCommon.resolveAnchors(anchorCtx.anchors, rawSelector, opts);
-            }
-            else
-                currentSelector = rawSelector;
-            const selectedIds = new Set();
-            const selectedColumns = [];
-            for (const provider of this.providers) {
-                const providerColumns = provider.selectColumns(currentSelector);
-                for (const col of providerColumns) {
-                    if (excludePredicate(col.spec))
-                        continue;
-                    if (selectedIds.has(col.id))
-                        throw new Error(`Duplicate column id ${col.id} in provider ${provider.constructor.name}`);
-                    const nativeId = plModelCommon.deriveNativeId(col.spec);
-                    if (selectedNativeIds.has(nativeId))
-                        continue;
-                    selectedIds.add(col.id);
-                    selectedNativeIds.add(nativeId);
-                    selectedColumns.push(col);
-                }
-            }
-            if (selectedColumns.length === 0)
-                continue;
-            const splitAxisIdxs = getSplitAxisIndices(rawSelector);
-            const needsSplitting = splitAxisIdxs.length > 0;
-            for (const column of selectedColumns) {
-                if (!plModelCommon.isPColumnSpec(column.spec))
-                    continue;
-                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 = pcolumn_data.convertOrParsePColumnData(column.data);
-                    if (!dataEntries) {
-                        if (dontWaitAllData)
-                            continue;
-                        return undefined;
-                    }
-                    if (!plModelCommon.isPartitionedDataInfoEntries(dataEntries))
-                        throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${dataEntries.type} for column ${column.id}`);
-                    const uniqueKeys = pcolumn_data.getUniquePartitionKeys(dataEntries);
-                    const maxSplitIdx = splitAxisIdxs[splitAxisIdxs.length - 1];
-                    if (maxSplitIdx >= dataEntries.partitionKeyLength)
-                        throw new Error(`Not enough partition keys (${dataEntries.partitionKeyLength}) for requested split axes (max index ${maxSplitIdx}) in column ${originalSpec.name}`);
-                    const axesLabels = splitAxisIdxs.map((idx) => this.findLabels(plModelCommon.getAxisId(originalSpec.axesSpec[idx])));
-                    const keyCombinations = [];
-                    const generateCombinations = (currentCombo, sAxisIdx) => {
-                        if (sAxisIdx >= splitAxisIdxs.length) {
-                            keyCombinations.push([...currentCombo]);
-                            if (keyCombinations.length > 10000)
-                                throw new Error("Too many key combinations, aborting.");
-                            return;
-                        }
-                        const axisIdx = splitAxisIdxs[sAxisIdx];
-                        if (axisIdx >= uniqueKeys.length)
-                            throw new Error(`Axis index ${axisIdx} out of bounds for unique keys array (length ${uniqueKeys.length}) during split key generation for column ${column.id}`);
-                        const axisValues = uniqueKeys[axisIdx];
-                        if (!axisValues || axisValues.length === 0) {
-                            keyCombinations.length = 0; // No combinations possible if one axis has no keys
-                            return;
-                        }
-                        for (const val of axisValues) {
-                            currentCombo.push(val);
-                            generateCombinations(currentCombo, sAxisIdx + 1);
-                            currentCombo.pop();
-                        }
-                    };
-                    generateCombinations([], 0);
-                    if (keyCombinations.length === 0)
-                        continue;
-                    const newAxesSpec = [...originalSpec.axesSpec];
-                    const splitAxisOriginalIdxs = splitAxisIdxs.map((idx) => idx); // Keep original indices for axisId lookup
-                    // Remove axes in reverse order to maintain correct indices during removal
-                    for (let i = splitAxisIdxs.length - 1; i >= 0; i--) {
-                        newAxesSpec.splice(splitAxisIdxs[i], 1);
-                    }
-                    const adjustedSpec = { ...originalSpec, axesSpec: newAxesSpec };
-                    for (const keyCombo of keyCombinations) {
-                        const splitFilters = keyCombo.map((value, sAxisIdx) => {
-                            const axisIdx = splitAxisOriginalIdxs[sAxisIdx]; // Use original index for lookup
-                            const axisId = plModelCommon.getAxisId(originalSpec.axesSpec[axisIdx]);
-                            const axisLabelMap = axesLabels[sAxisIdx];
-                            const label = axisLabelMap?.[value] ?? String(value);
-                            return { axisIdx, axisId, value: value, label };
-                        });
-                        intermediateResults.push({
-                            type: "split",
-                            originalColumn: column,
-                            spec: originalSpec,
-                            adjustedSpec,
-                            dataEntries,
-                            axisFilters: splitFilters,
-                        });
-                    }
-                }
-                else {
-                    intermediateResults.push({
-                        type: "direct",
-                        originalColumn: column,
-                        spec: originalSpec,
-                        adjustedSpec: originalSpec,
-                    });
-                }
-            }
-        }
-        if (intermediateResults.length === 0)
-            return [];
-        const labeledResults = label.deriveLabels(intermediateResults, (entry) => ({
-            spec: entry.spec,
-            suffixTrace: entry.type === "split" ? splitFiltersToTrace(entry.axisFilters) : undefined,
-        }), labelOps);
-        const result = [];
-        for (const { value: entry, label } of labeledResults) {
-            const { originalColumn, spec: originalSpec } = entry;
-            const axisFilters = entry.type === "split" ? entry.axisFilters : undefined;
-            const axisFiltersTuple = splitFiltersToAxisFilter(axisFilters);
-            let finalId;
-            if (anchorCtx)
-                finalId = anchorCtx.deriveS(originalSpec, axisFiltersTuple);
-            else
-                finalId = fallbackIdDeriver(originalColumn.id, axisFiltersTuple);
-            let finalSpec = { ...entry.adjustedSpec };
-            if (overrideLabelAnnotation) {
-                finalSpec = {
-                    ...finalSpec,
-                    annotations: {
-                        ...finalSpec.annotations,
-                        [plModelCommon.Annotation.Label]: label,
-                    },
-                };
-            }
-            result.push({
-                id: finalId,
-                spec: finalSpec,
-                data: () => entry.type === "split"
-                    ? plModelCommon.entriesToDataInfo(axis_filtering.filterDataInfoEntries(entry.dataEntries, axisFiltersTuple))
-                    : entry.originalColumn.data,
-                label: label,
-            });
-        }
-        const ids = new Set(result.map((entry) => entry.id));
-        if (enrichByLinkers && anchorCtx) {
-            const linkers = result.filter((entry) => plModelCommon.isLinkerColumn(entry.spec));
-            if (linkers.length === 0) {
-                return result;
-            }
-            const anchorAxes = Object.values(anchorCtx.anchors).flatMap((anchor) => anchor.axesSpec);
-            const linkerMap = plModelCommon.LinkerMap.fromColumns(linkers.map(plModelCommon.getColumnIdAndSpec));
-            // loose way of matching
-            function matchAxisIdFn(linkerKeyId, sourceAxisId) {
-                return plModelCommon.matchAxisId(linkerKeyId, sourceAxisId) || plModelCommon.matchAxisId(sourceAxisId, linkerKeyId);
-            }
-            // search all axes that can be reached by linkers from anchor axes; anchor axes are not in this list;
-            const availableByLinkersAxes = linkerMap.getReachableByLinkersAxesFromAxes(anchorAxes, matchAxisIdFn);
-            // search all columns that includes at least one of additional axes;
-            const availableByLinkersColumns = this.getUniversalEntries((spec) => !plModelCommon.isLinkerColumn(spec) &&
-                spec.axesSpec.some((columnAxisSpec) => {
-                    const columnAxisId = plModelCommon.getAxisId(columnAxisSpec);
-                    return availableByLinkersAxes.some((axis) => matchAxisIdFn(plModelCommon.getAxisId(axis), columnAxisId));
-                }), { anchorCtx, labelOps, dontWaitAllData, overrideLabelAnnotation, exclude });
-            if (availableByLinkersColumns) {
-                result.push(...availableByLinkersColumns.filter((entry) => !ids.has(entry.id)));
-            }
-        }
-        return result;
-    }
-    getColumns(predicateOrSelectors, opts) {
-        const entries = this.getUniversalEntries(predicateOrSelectors, {
-            overrideLabelAnnotation: true, // default for getColumns
-            ...opts,
-        });
-        if (!entries)
-            return undefined;
-        const columns = [];
-        for (const entry of entries) {
-            const data = entry.data();
-            if (!data) {
-                if (opts?.dontWaitAllData)
-                    continue;
-                return undefined;
-            }
-            columns.push({
-                id: entry.id,
-                spec: entry.spec,
-                data,
-            });
-        }
-        return columns;
-    }
+	if (typeof selector !== "object" || !("axes" in selector) || selector.axes === void 0) return [];
+	const splitIndices = selector.axes.map((axis, index) => typeof axis === "object" && "split" in axis && axis.split === true ? index : -1).filter((index) => index !== -1);
+	if (splitIndices.length > 0 && selector.partialAxesMatch !== void 0) throw new Error("Axis splitting is not supported when `partialAxesMatch` is defined.");
+	splitIndices.sort((a, b) => a - b);
+	return splitIndices;
 }
+var PColumnCollection = class {
+	defaultProviderStore = [];
+	providers = [new ArrayColumnProvider(this.defaultProviderStore)];
+	axisLabelProviders = [];
+	constructor() {}
+	addColumnProvider(provider) {
+		this.providers.push(provider);
+		return this;
+	}
+	addAxisLabelProvider(provider) {
+		this.axisLabelProviders.push(provider);
+		return this;
+	}
+	addColumns(columns) {
+		this.defaultProviderStore.push(...columns);
+		return this;
+	}
+	addColumn(column) {
+		this.defaultProviderStore.push(column);
+		return this;
+	}
+	/** Fetches labels for a given axis from the registered providers */
+	findLabels(axis) {
+		for (const provider of this.axisLabelProviders) {
+			const labels = provider.findLabels(axis);
+			if (labels) return labels;
+		}
+	}
+	getUniversalEntries(predicateOrSelectors, opts) {
+		const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude, enrichByLinkers = false } = opts ?? {};
+		const labelOps = {
+			...overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false ? { includeNativeLabel: true } : {},
+			...rawLabelOps
+		};
+		let excludePredicate = () => false;
+		if (exclude) {
+			const excludePredicartes = (Array.isArray(exclude) ? exclude : [exclude]).map((selector) => {
+				if (hasAnchors(selector)) {
+					if (!anchorCtx) throw new Error("Anchored selectors in exclude require an AnchoredIdDeriver to be provided in options.");
+					return (0, _milaboratories_pl_model_common.selectorsToPredicate)((0, _milaboratories_pl_model_common.resolveAnchors)(anchorCtx.anchors, selector, opts));
+				} else return (0, _milaboratories_pl_model_common.selectorsToPredicate)(selector);
+			});
+			excludePredicate = (spec) => excludePredicartes.some((predicate) => predicate(spec));
+		}
+		const selectorsArray = typeof predicateOrSelectors === "function" ? [predicateOrSelectors] : Array.isArray(predicateOrSelectors) ? predicateOrSelectors : [predicateOrSelectors];
+		const intermediateResults = [];
+		const selectedNativeIds = /* @__PURE__ */ new Set();
+		for (const rawSelector of selectorsArray) {
+			const usesAnchors = hasAnchors(rawSelector);
+			let currentSelector;
+			if (usesAnchors) {
+				if (!anchorCtx) throw new Error("Anchored selectors require an AnchoredIdDeriver to be provided in options.");
+				currentSelector = (0, _milaboratories_pl_model_common.resolveAnchors)(anchorCtx.anchors, rawSelector, opts);
+			} else currentSelector = rawSelector;
+			const selectedIds = /* @__PURE__ */ new Set();
+			const selectedColumns = [];
+			for (const provider of this.providers) {
+				const providerColumns = provider.selectColumns(currentSelector);
+				for (const col of providerColumns) {
+					if (excludePredicate(col.spec)) continue;
+					if (selectedIds.has(col.id)) throw new Error(`Duplicate column id ${col.id} in provider ${provider.constructor.name}`);
+					const nativeId = (0, _milaboratories_pl_model_common.deriveNativeId)(col.spec);
+					if (selectedNativeIds.has(nativeId)) continue;
+					selectedIds.add(col.id);
+					selectedNativeIds.add(nativeId);
+					selectedColumns.push(col);
+				}
+			}
+			if (selectedColumns.length === 0) continue;
+			const splitAxisIdxs = getSplitAxisIndices(rawSelector);
+			const needsSplitting = splitAxisIdxs.length > 0;
+			for (const column of selectedColumns) {
+				if (!(0, _milaboratories_pl_model_common.isPColumnSpec)(column.spec)) continue;
+				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 = require_pcolumn_data.convertOrParsePColumnData(column.data);
+					if (!dataEntries) {
+						if (dontWaitAllData) continue;
+						return;
+					}
+					if (!(0, _milaboratories_pl_model_common.isPartitionedDataInfoEntries)(dataEntries)) throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${dataEntries.type} for column ${column.id}`);
+					const uniqueKeys = require_pcolumn_data.getUniquePartitionKeys(dataEntries);
+					const maxSplitIdx = splitAxisIdxs[splitAxisIdxs.length - 1];
+					if (maxSplitIdx >= dataEntries.partitionKeyLength) throw new Error(`Not enough partition keys (${dataEntries.partitionKeyLength}) for requested split axes (max index ${maxSplitIdx}) in column ${originalSpec.name}`);
+					const axesLabels = splitAxisIdxs.map((idx) => this.findLabels((0, _milaboratories_pl_model_common.getAxisId)(originalSpec.axesSpec[idx])));
+					const keyCombinations = [];
+					const generateCombinations = (currentCombo, sAxisIdx) => {
+						if (sAxisIdx >= splitAxisIdxs.length) {
+							keyCombinations.push([...currentCombo]);
+							if (keyCombinations.length > 1e4) throw new Error("Too many key combinations, aborting.");
+							return;
+						}
+						const axisIdx = splitAxisIdxs[sAxisIdx];
+						if (axisIdx >= uniqueKeys.length) throw new Error(`Axis index ${axisIdx} out of bounds for unique keys array (length ${uniqueKeys.length}) during split key generation for column ${column.id}`);
+						const axisValues = uniqueKeys[axisIdx];
+						if (!axisValues || axisValues.length === 0) {
+							keyCombinations.length = 0;
+							return;
+						}
+						for (const val of axisValues) {
+							currentCombo.push(val);
+							generateCombinations(currentCombo, sAxisIdx + 1);
+							currentCombo.pop();
+						}
+					};
+					generateCombinations([], 0);
+					if (keyCombinations.length === 0) continue;
+					const newAxesSpec = [...originalSpec.axesSpec];
+					const splitAxisOriginalIdxs = splitAxisIdxs.map((idx) => idx);
+					for (let i = splitAxisIdxs.length - 1; i >= 0; i--) newAxesSpec.splice(splitAxisIdxs[i], 1);
+					const adjustedSpec = {
+						...originalSpec,
+						axesSpec: newAxesSpec
+					};
+					for (const keyCombo of keyCombinations) {
+						const splitFilters = keyCombo.map((value, sAxisIdx) => {
+							const axisIdx = splitAxisOriginalIdxs[sAxisIdx];
+							return {
+								axisIdx,
+								axisId: (0, _milaboratories_pl_model_common.getAxisId)(originalSpec.axesSpec[axisIdx]),
+								value,
+								label: axesLabels[sAxisIdx]?.[value] ?? String(value)
+							};
+						});
+						intermediateResults.push({
+							type: "split",
+							originalColumn: column,
+							spec: originalSpec,
+							adjustedSpec,
+							dataEntries,
+							axisFilters: splitFilters
+						});
+					}
+				} else intermediateResults.push({
+					type: "direct",
+					originalColumn: column,
+					spec: originalSpec,
+					adjustedSpec: originalSpec
+				});
+			}
+		}
+		if (intermediateResults.length === 0) return [];
+		const labeledResults = require_label.deriveLabels(intermediateResults, (entry) => ({
+			spec: entry.spec,
+			suffixTrace: entry.type === "split" ? splitFiltersToTrace(entry.axisFilters) : void 0
+		}), labelOps);
+		const result = [];
+		for (const { value: entry, label } of labeledResults) {
+			const { originalColumn, spec: originalSpec } = entry;
+			const axisFiltersTuple = splitFiltersToAxisFilter(entry.type === "split" ? entry.axisFilters : void 0);
+			let finalId;
+			if (anchorCtx) finalId = anchorCtx.deriveS(originalSpec, axisFiltersTuple);
+			else finalId = fallbackIdDeriver(originalColumn.id, axisFiltersTuple);
+			let finalSpec = { ...entry.adjustedSpec };
+			if (overrideLabelAnnotation) finalSpec = {
+				...finalSpec,
+				annotations: {
+					...finalSpec.annotations,
+					[_milaboratories_pl_model_common.Annotation.Label]: label
+				}
+			};
+			result.push({
+				id: finalId,
+				spec: finalSpec,
+				data: () => entry.type === "split" ? (0, _milaboratories_pl_model_common.entriesToDataInfo)(require_axis_filtering.filterDataInfoEntries(entry.dataEntries, axisFiltersTuple)) : entry.originalColumn.data,
+				label
+			});
+		}
+		const ids = new Set(result.map((entry) => entry.id));
+		if (enrichByLinkers && anchorCtx) {
+			const linkers = result.filter((entry) => (0, _milaboratories_pl_model_common.isLinkerColumn)(entry.spec));
+			if (linkers.length === 0) return result;
+			const anchorAxes = Object.values(anchorCtx.anchors).flatMap((anchor) => anchor.axesSpec);
+			const linkerMap = _milaboratories_pl_model_common.LinkerMap.fromColumns(linkers.map(_milaboratories_pl_model_common.getColumnIdAndSpec));
+			function matchAxisIdFn(linkerKeyId, sourceAxisId) {
+				return (0, _milaboratories_pl_model_common.matchAxisId)(linkerKeyId, sourceAxisId) || (0, _milaboratories_pl_model_common.matchAxisId)(sourceAxisId, linkerKeyId);
+			}
+			const availableByLinkersAxes = linkerMap.getReachableByLinkersAxesFromAxes(anchorAxes, matchAxisIdFn);
+			const availableByLinkersColumns = this.getUniversalEntries((spec) => !(0, _milaboratories_pl_model_common.isLinkerColumn)(spec) && spec.axesSpec.some((columnAxisSpec) => {
+				const columnAxisId = (0, _milaboratories_pl_model_common.getAxisId)(columnAxisSpec);
+				return availableByLinkersAxes.some((axis) => matchAxisIdFn((0, _milaboratories_pl_model_common.getAxisId)(axis), columnAxisId));
+			}), {
+				anchorCtx,
+				labelOps,
+				dontWaitAllData,
+				overrideLabelAnnotation,
+				exclude
+			});
+			if (availableByLinkersColumns) result.push(...availableByLinkersColumns.filter((entry) => !ids.has(entry.id)));
+		}
+		return result;
+	}
+	getColumns(predicateOrSelectors, opts) {
+		const entries = this.getUniversalEntries(predicateOrSelectors, {
+			overrideLabelAnnotation: true,
+			...opts
+		});
+		if (!entries) return void 0;
+		const columns = [];
+		for (const entry of entries) {
+			const data = entry.data();
+			if (!data) {
+				if (opts?.dontWaitAllData) continue;
+				return;
+			}
+			columns.push({
+				id: entry.id,
+				spec: entry.spec,
+				data
+			});
+		}
+		return columns;
+	}
+};
 
+//#endregion
 exports.PColumnCollection = PColumnCollection;
-//# sourceMappingURL=column_collection.cjs.map
+//# sourceMappingURL=column_collection.cjs.map