@platforma-sdk/model 1.58.3 → 1.58.9

package/dist/render/api.js

@@ -1,591 +1,489 @@
-import { selectorsToPredicate, withEnrichments, AnchoredIdDeriver, isPlRef, mapValueInVOE, mapPObjectData, ensurePColumn, isPColumnSpec, isPColumn, PColumnName, readAnnotation, isDataInfo, extractAllColumns, mapPTableDef, collectSpecQueryColumns, mapPTableDefV2, parseJson, mapDataInfo } from '@milaboratories/pl-model-common';
-import canonicalize from 'canonicalize';
-import { getCfgRenderCtx } from '../internal.js';
-import { getPluginData } from '../block_storage.js';
-import { TreeNodeAccessor, ifDef } from './accessor.js';
-import { StagingAccessorName, MainAccessorName } from './internal.js';
-import { PColumnCollection } from './util/column_collection.js';
-import { deriveLabels } from './util/label.js';
-import { patchInSetFilters } from './util/pframe_upgraders.js';
-import { allPColumnsReady } from './util/pcolumn_data.js';
+import { getPluginData } from "../block_storage.js";
+import { getCfgRenderCtx } from "../internal.js";
+import { TreeNodeAccessor, ifDef } from "./accessor.js";
+import { MainAccessorName, StagingAccessorName } from "./internal.js";
+import { deriveLabels } from "./util/label.js";
+import { allPColumnsReady } from "./util/pcolumn_data.js";
+import { PColumnCollection } from "./util/column_collection.js";
+import { patchInSetFilters } from "./util/pframe_upgraders.js";
+import { AnchoredIdDeriver, PColumnName, collectSpecQueryColumns, ensurePColumn, extractAllColumns, isDataInfo, isPColumn, isPColumnSpec, isPlRef, mapDataInfo, mapPObjectData, mapPTableDef, mapPTableDefV2, mapValueInVOE, parseJson, readAnnotation, selectorsToPredicate, withEnrichments } from "@milaboratories/pl-model-common";
+import canonicalize from "canonicalize";
 
+//#region src/render/api.ts
 /**
- * Helper function to match domain objects
- * @param query Optional domain to match against
- * @param target Optional domain to match
- * @returns true if domains match, false otherwise
- */
+* Helper function to match domain objects
+* @param query Optional domain to match against
+* @param target Optional domain to match
+* @returns true if domains match, false otherwise
+*/
 function matchDomain(query, target) {
-    if (query === undefined)
-        return target === undefined;
-    if (target === undefined)
-        return true;
-    for (const k in target) {
-        if (query[k] !== target[k])
-            return false;
-    }
-    return true;
+	if (query === void 0) return target === void 0;
+	if (target === void 0) return true;
+	for (const k in target) if (query[k] !== target[k]) return false;
+	return true;
 }
 /**
- * Transforms PColumn data into the internal representation expected by the platform
- * @param data Data from a PColumn to transform
- * @returns Transformed data compatible with platform API
- */
+* Transforms PColumn data into the internal representation expected by the platform
+* @param data Data from a PColumn to transform
+* @returns Transformed data compatible with platform API
+*/
 function transformPColumnData(data) {
-    return mapPObjectData(data, (d) => {
-        if (d instanceof TreeNodeAccessor) {
-            return d.handle;
-        }
-        else if (isDataInfo(d)) {
-            return mapDataInfo(d, (accessor) => accessor.handle);
-        }
-        else {
-            return d;
-        }
-    });
-}
-class ResultPool {
-    ctx = getCfgRenderCtx();
-    /**
-     * @deprecated use getOptions()
-     */
-    calculateOptions(predicate) {
-        return this.ctx.calculateOptions(predicate);
-    }
-    getOptions(predicateOrSelector, opts) {
-        const predicate = typeof predicateOrSelector === "function"
-            ? predicateOrSelector
-            : selectorsToPredicate(predicateOrSelector);
-        const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
-        let labelOps = {};
-        let refsWithEnrichments = false;
-        if (typeof opts !== "undefined") {
-            if (typeof opts === "function") {
-                labelOps = opts;
-            }
-            else if (typeof opts === "object") {
-                if ("includeNativeLabel" in opts || "separator" in opts || "addLabelAsSuffix" in opts) {
-                    labelOps = opts;
-                }
-                else {
-                    opts = opts;
-                    labelOps = opts.label ?? {};
-                    refsWithEnrichments = opts.refsWithEnrichments ?? false;
-                }
-            }
-        }
-        if (typeof labelOps === "object")
-            return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(({ value: { ref }, label }) => ({
-                ref: withEnrichments(ref, refsWithEnrichments),
-                label,
-            }));
-        else
-            return filtered.map(({ ref, obj }) => ({
-                ref: withEnrichments(ref, refsWithEnrichments),
-                label: labelOps(obj, ref),
-            }));
-    }
-    resolveAnchorCtx(anchorsOrCtx) {
-        if (anchorsOrCtx instanceof AnchoredIdDeriver)
-            return anchorsOrCtx;
-        const resolvedAnchors = {};
-        for (const [key, value] of Object.entries(anchorsOrCtx)) {
-            if (isPlRef(value)) {
-                const resolvedSpec = this.getPColumnSpecByRef(value);
-                if (!resolvedSpec)
-                    return undefined;
-                resolvedAnchors[key] = resolvedSpec;
-            }
-            else {
-                resolvedAnchors[key] = value;
-            }
-        }
-        return new AnchoredIdDeriver(resolvedAnchors);
-    }
-    /**
-     * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
-     *
-     * @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)
-     * @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)
-     * @param opts - Optional configuration for label generation and data waiting
-     * @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing
-     */
-    getAnchoredPColumns(anchorsOrCtx, predicateOrSelectors, opts) {
-        const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
-        if (!anchorCtx)
-            return undefined;
-        return new PColumnCollection()
-            .addColumnProvider(this)
-            .addAxisLabelProvider(this)
-            .getColumns(predicateOrSelectors, {
-            ...opts,
-            anchorCtx,
-        });
-    }
-    /**
-     * Calculates anchored identifier options for columns matching a given predicate and returns their
-     * canonicalized representations.
-     *
-     * This function filters column specifications from the result pool that match the provided predicate,
-     * creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value
-     * pairs for UI components (like dropdowns).
-     *
-     * @param anchorsOrCtx - Either:
-     *                     - An existing AnchorCtx instance
-     *                     - A record mapping anchor IDs to PColumnSpec objects
-     *                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)
-     * @param predicateOrSelectors - Either:
-     *                            - A predicate function that takes a PColumnSpec and returns a boolean.
-     *                              Only specs that return true will be included.
-     *                            - An APColumnSelector object for declarative filtering, which will be
-     *                              resolved against the provided anchors and matched using matchPColumn.
-     *                            - An array of APColumnSelector objects - columns matching ANY selector
-     *                              in the array will be included (OR operation).
-     * @param opts - Optional configuration for label generation:
-     *                 - labelOps: Optional configuration for label generation:
-     *                   - includeNativeLabel: Whether to include native column labels
-     *                   - separator: String to use between label parts (defaults to " / ")
-     *                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix
-     *                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,
-     *                                    if at least one column that requires splitting is missing data)
-     * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
-     *          or undefined if any PlRef resolution fails.
-     */
-    getCanonicalOptions(anchorsOrCtx, predicateOrSelectors, opts) {
-        const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
-        if (!anchorCtx)
-            return undefined;
-        const entries = new PColumnCollection()
-            .addColumnProvider(this)
-            .addAxisLabelProvider(this)
-            .getUniversalEntries(predicateOrSelectors, {
-            ...opts,
-            anchorCtx,
-        });
-        if (!entries)
-            return undefined;
-        return entries.map((item) => ({
-            value: item.id,
-            label: item.label,
-        }));
-    }
-    /**
-     * @deprecated use getData()
-     */
-    getDataFromResultPool() {
-        return this.getData();
-    }
-    getData() {
-        const result = this.ctx.getDataFromResultPool();
-        return {
-            isComplete: result.isComplete,
-            entries: result.entries.map((e) => ({
-                ref: e.ref,
-                obj: {
-                    ...e.obj,
-                    data: new TreeNodeAccessor(e.obj.data, [e.ref.blockId, e.ref.name]),
-                },
-            })),
-        };
-    }
-    /**
-     * @deprecated use getDataWithErrors()
-     */
-    getDataWithErrorsFromResultPool() {
-        return this.getDataWithErrors();
-    }
-    getDataWithErrors() {
-        const result = this.ctx.getDataWithErrorsFromResultPool();
-        return {
-            isComplete: result.isComplete,
-            entries: result.entries.map((e) => ({
-                ref: e.ref,
-                obj: {
-                    ...e.obj,
-                    data: mapValueInVOE(e.obj.data, (handle) => new TreeNodeAccessor(handle, [e.ref.blockId, e.ref.name])),
-                },
-            })),
-        };
-    }
-    /**
-     * @deprecated use getSpecs()
-     */
-    getSpecsFromResultPool() {
-        return this.getSpecs();
-    }
-    getSpecs() {
-        return this.ctx.getSpecsFromResultPool();
-    }
-    /**
-     * @param ref a Ref
-     * @returns data associated with the ref
-     */
-    getDataByRef(ref) {
-        // @TODO remove after 1 Jan 2025; forward compatibility
-        if (typeof this.ctx.getDataFromResultPoolByRef === "undefined")
-            return this.getData().entries.find((f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name)?.obj;
-        const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name); // Keep original call
-        // Need to handle undefined case before mapping
-        if (!data)
-            return undefined;
-        return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));
-    }
-    /**
-     * Returns data associated with the ref ensuring that it is a p-column.
-     * @param ref a Ref
-     * @returns p-column associated with the ref
-     */
-    getPColumnByRef(ref) {
-        const data = this.getDataByRef(ref);
-        if (!data)
-            return undefined;
-        return ensurePColumn(data);
-    }
-    /**
-     * Returns spec associated with the ref ensuring that it is a p-column spec.
-     * @param ref a Ref
-     * @returns p-column spec associated with the ref
-     */
-    getPColumnSpecByRef(ref) {
-        const spec = this.getSpecByRef(ref);
-        if (!spec)
-            return undefined;
-        if (!isPColumnSpec(spec))
-            throw new Error(`not a PColumn spec (kind = ${spec.kind})`);
-        return spec;
-    }
-    /**
-     * @param ref a Ref
-     * @returns object spec associated with the ref
-     */
-    getSpecByRef(ref) {
-        return this.ctx.getSpecFromResultPoolByRef(ref.blockId, ref.name);
-    }
-    /**
-     * @param spec object specification
-     * @returns array of data objects with compatible specs
-     * @deprecated delete this method after Jan 1, 2025
-     */
-    findDataWithCompatibleSpec(spec) {
-        const result = [];
-        out: for (const data of this.getData().entries) {
-            if (!isPColumnSpec(data.obj.spec)) {
-                continue;
-            }
-            const oth = data.obj.spec;
-            if (spec.name !== oth.name) {
-                continue;
-            }
-            if (spec.valueType !== oth.valueType) {
-                continue;
-            }
-            if (spec.axesSpec.length !== oth.axesSpec.length) {
-                continue;
-            }
-            if (!matchDomain(spec.domain, oth.domain)) {
-                continue;
-            }
-            for (let i = 0; i < spec.axesSpec.length; ++i) {
-                const qAx = spec.axesSpec[i];
-                const tAx = oth.axesSpec[i];
-                if (qAx.name !== tAx.name) {
-                    continue out;
-                }
-                if (qAx.type !== tAx.type) {
-                    continue out;
-                }
-                if (!matchDomain(qAx.domain, tAx.domain)) {
-                    continue out;
-                }
-            }
-            result.push(data.obj);
-        }
-        return result;
-    }
-    /**
-     * Find labels data for a given axis id. It will search for a label column and return its data as a map.
-     * @returns a map of axis value => label
-     */
-    findLabels(axis) {
-        const dataPool = this.getData();
-        for (const column of dataPool.entries) {
-            if (!isPColumn(column.obj))
-                continue;
-            const spec = column.obj.spec;
-            if (spec.name === PColumnName.Label &&
-                spec.axesSpec.length === 1 &&
-                spec.axesSpec[0].name === axis.name &&
-                spec.axesSpec[0].type === axis.type &&
-                matchDomain(axis.domain, spec.axesSpec[0].domain)) {
-                if (column.obj.data.resourceType.name !== "PColumnData/Json") {
-                    throw Error(`Expected JSON column for labels, got: ${column.obj.data.resourceType.name}`);
-                }
-                const labels = Object.fromEntries(Object.entries(column.obj.data.getDataAsJson().data).map((e) => [JSON.parse(e[0])[0], e[1]]));
-                return labels;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Selects columns based on the provided selectors, returning PColumn objects
-     * with lazily loaded data.
-     *
-     * @param selectors - A predicate function, a single selector, or an array of selectors.
-     * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
-     */
-    selectColumns(selectors) {
-        const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
-        const matchedSpecs = this.getSpecs().entries.filter(({ obj: spec }) => {
-            if (!isPColumnSpec(spec))
-                return false;
-            return predicate(spec);
-        });
-        // Map specs to PColumn objects with lazy data loading
-        return matchedSpecs.map(({ ref, obj: spec }) => {
-            // Type assertion needed because filter ensures it's PColumnSpec
-            const pcolumnSpec = spec;
-            let _cachedData = null; // Use null to distinguish initial state from undefined result
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const self = this; // Capture 'this' for use inside the getter
-            return {
-                id: canonicalize(ref),
-                spec: pcolumnSpec,
-                get data() {
-                    if (_cachedData !== null) {
-                        return _cachedData; // Return cached data (could be undefined if fetch failed)
-                    }
-                    _cachedData = self.getPColumnByRef(ref)?.data;
-                    return _cachedData;
-                },
-            }; // Cast needed because 'data' is a getter
-        });
-    }
-    /**
-     * Find labels data for a given axis id of a p-column.
-     * @returns a map of axis value => label
-     */
-    findLabelsForColumnAxis(column, axisIdx) {
-        const labels = this.findLabels(column.axesSpec[axisIdx]);
-        if (!labels)
-            return undefined;
-        const axisKeys = readAnnotation(column, `pl7.app/axisKeys/${axisIdx}`);
-        if (axisKeys !== undefined) {
-            const keys = JSON.parse(axisKeys);
-            return Object.fromEntries(keys.map((key) => {
-                return [key, labels[key] ?? "Unlabelled"];
-            }));
-        }
-        else {
-            return labels;
-        }
-    }
+	return mapPObjectData(data, (d) => {
+		if (d instanceof TreeNodeAccessor) return d.handle;
+		else if (isDataInfo(d)) return mapDataInfo(d, (accessor) => accessor.handle);
+		else return d;
+	});
 }
+var ResultPool = class {
+	ctx = getCfgRenderCtx();
+	/**
+	* @deprecated use getOptions()
+	*/
+	calculateOptions(predicate) {
+		return this.ctx.calculateOptions(predicate);
+	}
+	getOptions(predicateOrSelector, opts) {
+		const predicate = typeof predicateOrSelector === "function" ? predicateOrSelector : selectorsToPredicate(predicateOrSelector);
+		const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
+		let labelOps = {};
+		let refsWithEnrichments = false;
+		if (typeof opts !== "undefined") {
+			if (typeof opts === "function") labelOps = opts;
+			else if (typeof opts === "object") if ("includeNativeLabel" in opts || "separator" in opts || "addLabelAsSuffix" in opts) labelOps = opts;
+			else {
+				opts = opts;
+				labelOps = opts.label ?? {};
+				refsWithEnrichments = opts.refsWithEnrichments ?? false;
+			}
+		}
+		if (typeof labelOps === "object") return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(({ value: { ref }, label }) => ({
+			ref: withEnrichments(ref, refsWithEnrichments),
+			label
+		}));
+		else return filtered.map(({ ref, obj }) => ({
+			ref: withEnrichments(ref, refsWithEnrichments),
+			label: labelOps(obj, ref)
+		}));
+	}
+	resolveAnchorCtx(anchorsOrCtx) {
+		if (anchorsOrCtx instanceof AnchoredIdDeriver) return anchorsOrCtx;
+		const resolvedAnchors = {};
+		for (const [key, value] of Object.entries(anchorsOrCtx)) if (isPlRef(value)) {
+			const resolvedSpec = this.getPColumnSpecByRef(value);
+			if (!resolvedSpec) return void 0;
+			resolvedAnchors[key] = resolvedSpec;
+		} else resolvedAnchors[key] = value;
+		return new AnchoredIdDeriver(resolvedAnchors);
+	}
+	/**
+	* Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
+	*
+	* @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)
+	* @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)
+	* @param opts - Optional configuration for label generation and data waiting
+	* @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing
+	*/
+	getAnchoredPColumns(anchorsOrCtx, predicateOrSelectors, opts) {
+		const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
+		if (!anchorCtx) return void 0;
+		return new PColumnCollection().addColumnProvider(this).addAxisLabelProvider(this).getColumns(predicateOrSelectors, {
+			...opts,
+			anchorCtx
+		});
+	}
+	/**
+	* Calculates anchored identifier options for columns matching a given predicate and returns their
+	* canonicalized representations.
+	*
+	* This function filters column specifications from the result pool that match the provided predicate,
+	* creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value
+	* pairs for UI components (like dropdowns).
+	*
+	* @param anchorsOrCtx - Either:
+	*                     - An existing AnchorCtx instance
+	*                     - A record mapping anchor IDs to PColumnSpec objects
+	*                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)
+	* @param predicateOrSelectors - Either:
+	*                            - A predicate function that takes a PColumnSpec and returns a boolean.
+	*                              Only specs that return true will be included.
+	*                            - An APColumnSelector object for declarative filtering, which will be
+	*                              resolved against the provided anchors and matched using matchPColumn.
+	*                            - An array of APColumnSelector objects - columns matching ANY selector
+	*                              in the array will be included (OR operation).
+	* @param opts - Optional configuration for label generation:
+	*                 - labelOps: Optional configuration for label generation:
+	*                   - includeNativeLabel: Whether to include native column labels
+	*                   - separator: String to use between label parts (defaults to " / ")
+	*                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix
+	*                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,
+	*                                    if at least one column that requires splitting is missing data)
+	* @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
+	*          or undefined if any PlRef resolution fails.
+	*/
+	getCanonicalOptions(anchorsOrCtx, predicateOrSelectors, opts) {
+		const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
+		if (!anchorCtx) return void 0;
+		const entries = new PColumnCollection().addColumnProvider(this).addAxisLabelProvider(this).getUniversalEntries(predicateOrSelectors, {
+			...opts,
+			anchorCtx
+		});
+		if (!entries) return void 0;
+		return entries.map((item) => ({
+			value: item.id,
+			label: item.label
+		}));
+	}
+	/**
+	* @deprecated use getData()
+	*/
+	getDataFromResultPool() {
+		return this.getData();
+	}
+	getData() {
+		const result = this.ctx.getDataFromResultPool();
+		return {
+			isComplete: result.isComplete,
+			entries: result.entries.map((e) => ({
+				ref: e.ref,
+				obj: {
+					...e.obj,
+					data: new TreeNodeAccessor(e.obj.data, [e.ref.blockId, e.ref.name])
+				}
+			}))
+		};
+	}
+	/**
+	* @deprecated use getDataWithErrors()
+	*/
+	getDataWithErrorsFromResultPool() {
+		return this.getDataWithErrors();
+	}
+	getDataWithErrors() {
+		const result = this.ctx.getDataWithErrorsFromResultPool();
+		return {
+			isComplete: result.isComplete,
+			entries: result.entries.map((e) => ({
+				ref: e.ref,
+				obj: {
+					...e.obj,
+					data: mapValueInVOE(e.obj.data, (handle) => new TreeNodeAccessor(handle, [e.ref.blockId, e.ref.name]))
+				}
+			}))
+		};
+	}
+	/**
+	* @deprecated use getSpecs()
+	*/
+	getSpecsFromResultPool() {
+		return this.getSpecs();
+	}
+	getSpecs() {
+		return this.ctx.getSpecsFromResultPool();
+	}
+	/**
+	* @param ref a Ref
+	* @returns data associated with the ref
+	*/
+	getDataByRef(ref) {
+		if (typeof this.ctx.getDataFromResultPoolByRef === "undefined") return this.getData().entries.find((f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name)?.obj;
+		const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name);
+		if (!data) return void 0;
+		return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));
+	}
+	/**
+	* Returns data associated with the ref ensuring that it is a p-column.
+	* @param ref a Ref
+	* @returns p-column associated with the ref
+	*/
+	getPColumnByRef(ref) {
+		const data = this.getDataByRef(ref);
+		if (!data) return void 0;
+		return ensurePColumn(data);
+	}
+	/**
+	* Returns spec associated with the ref ensuring that it is a p-column spec.
+	* @param ref a Ref
+	* @returns p-column spec associated with the ref
+	*/
+	getPColumnSpecByRef(ref) {
+		const spec = this.getSpecByRef(ref);
+		if (!spec) return void 0;
+		if (!isPColumnSpec(spec)) throw new Error(`not a PColumn spec (kind = ${spec.kind})`);
+		return spec;
+	}
+	/**
+	* @param ref a Ref
+	* @returns object spec associated with the ref
+	*/
+	getSpecByRef(ref) {
+		return this.ctx.getSpecFromResultPoolByRef(ref.blockId, ref.name);
+	}
+	/**
+	* @param spec object specification
+	* @returns array of data objects with compatible specs
+	* @deprecated delete this method after Jan 1, 2025
+	*/
+	findDataWithCompatibleSpec(spec) {
+		const result = [];
+		out: for (const data of this.getData().entries) {
+			if (!isPColumnSpec(data.obj.spec)) continue;
+			const oth = data.obj.spec;
+			if (spec.name !== oth.name) continue;
+			if (spec.valueType !== oth.valueType) continue;
+			if (spec.axesSpec.length !== oth.axesSpec.length) continue;
+			if (!matchDomain(spec.domain, oth.domain)) continue;
+			for (let i = 0; i < spec.axesSpec.length; ++i) {
+				const qAx = spec.axesSpec[i];
+				const tAx = oth.axesSpec[i];
+				if (qAx.name !== tAx.name) continue out;
+				if (qAx.type !== tAx.type) continue out;
+				if (!matchDomain(qAx.domain, tAx.domain)) continue out;
+			}
+			result.push(data.obj);
+		}
+		return result;
+	}
+	/**
+	* Find labels data for a given axis id. It will search for a label column and return its data as a map.
+	* @returns a map of axis value => label
+	*/
+	findLabels(axis) {
+		const dataPool = this.getData();
+		for (const column of dataPool.entries) {
+			if (!isPColumn(column.obj)) continue;
+			const spec = column.obj.spec;
+			if (spec.name === PColumnName.Label && spec.axesSpec.length === 1 && spec.axesSpec[0].name === axis.name && spec.axesSpec[0].type === axis.type && matchDomain(axis.domain, spec.axesSpec[0].domain)) {
+				if (column.obj.data.resourceType.name !== "PColumnData/Json") throw Error(`Expected JSON column for labels, got: ${column.obj.data.resourceType.name}`);
+				return Object.fromEntries(Object.entries(column.obj.data.getDataAsJson().data).map((e) => [JSON.parse(e[0])[0], e[1]]));
+			}
+		}
+	}
+	/**
+	* Selects columns based on the provided selectors, returning PColumn objects
+	* with lazily loaded data.
+	*
+	* @param selectors - A predicate function, a single selector, or an array of selectors.
+	* @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
+	*/
+	selectColumns(selectors) {
+		const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
+		return this.getSpecs().entries.filter(({ obj: spec }) => {
+			if (!isPColumnSpec(spec)) return false;
+			return predicate(spec);
+		}).map(({ ref, obj: spec }) => {
+			const pcolumnSpec = spec;
+			let _cachedData = null;
+			const self = this;
+			return {
+				id: canonicalize(ref),
+				spec: pcolumnSpec,
+				get data() {
+					if (_cachedData !== null) return _cachedData;
+					_cachedData = self.getPColumnByRef(ref)?.data;
+					return _cachedData;
+				}
+			};
+		});
+	}
+	/**
+	* Find labels data for a given axis id of a p-column.
+	* @returns a map of axis value => label
+	*/
+	findLabelsForColumnAxis(column, axisIdx) {
+		const labels = this.findLabels(column.axesSpec[axisIdx]);
+		if (!labels) return void 0;
+		const axisKeys = readAnnotation(column, `pl7.app/axisKeys/${axisIdx}`);
+		if (axisKeys !== void 0) {
+			const keys = JSON.parse(axisKeys);
+			return Object.fromEntries(keys.map((key) => {
+				return [key, labels[key] ?? "Unlabelled"];
+			}));
+		} else return labels;
+	}
+};
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */
-class RenderCtxBase {
-    ctx;
-    constructor() {
-        this.ctx = getCfgRenderCtx();
-    }
-    dataCache;
-    get data() {
-        if (this.dataCache === undefined) {
-            const raw = this.ctx.data;
-            const value = typeof raw === "function" ? raw() : raw;
-            this.dataCache = { v: value ? JSON.parse(value) : {} };
-        }
-        return this.dataCache.v;
-    }
-    // lazy rendering because this feature is rarely used
-    activeArgsCache;
-    /**
-     * Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
-     * Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.
-     * */
-    get activeArgs() {
-        if (this.activeArgsCache === undefined) {
-            const raw = this.ctx.activeArgs;
-            const value = typeof raw === "function" ? raw() : raw;
-            this.activeArgsCache = {
-                v: value ? JSON.parse(value) : undefined,
-            };
-        }
-        return this.activeArgsCache.v;
-    }
-    // /** Can be used to determine features provided by the desktop instance. */
-    // public get featureFlags() {
-    //   return this.ctx.featureFlags;
-    // }
-    getNamedAccessor(name) {
-        return ifDef(this.ctx.getAccessorHandleByName(name), (accessor) => new TreeNodeAccessor(accessor, [name]));
-    }
-    get prerun() {
-        return this.getNamedAccessor(StagingAccessorName);
-    }
-    get outputs() {
-        return this.getNamedAccessor(MainAccessorName);
-    }
-    resultPool = new ResultPool();
-    /**
-     * Find labels data for a given axis id. It will search for a label column and return its data as a map.
-     * @returns a map of axis value => label
-     * @deprecated Use resultPool.findLabels instead
-     */
-    findLabels(axis) {
-        return this.resultPool.findLabels(axis);
-    }
-    verifyInlineAndExplicitColumnsSupport(columns) {
-        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
-        // Removed redundant explicitColumns check
-    }
-    patchPTableDef(def) {
-        if (!this.ctx.featureFlags?.pTablePartitionFiltersSupport) {
-            // For old desktop move all partition filters to filters field as it doesn't read partitionFilters field
-            def = {
-                ...def,
-                partitionFilters: [],
-                filters: [...def.partitionFilters, ...def.filters],
-            };
-        }
-        if (!this.ctx.featureFlags?.pFrameInSetFilterSupport) {
-            def = {
-                ...def,
-                partitionFilters: patchInSetFilters(def.partitionFilters),
-                filters: patchInSetFilters(def.filters),
-            };
-        }
-        return def;
-    }
-    // TODO remove all non-PColumn fields
-    createPFrame(def) {
-        this.verifyInlineAndExplicitColumnsSupport(def);
-        if (!allPColumnsReady(def))
-            return undefined;
-        return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
-    }
-    createPTable(def) {
-        let rawDef;
-        if ("columns" in def) {
-            rawDef = this.patchPTableDef({
-                src: {
-                    type: "full",
-                    entries: def.columns.map((c) => ({ type: "column", column: c })),
-                },
-                partitionFilters: def.filters ?? [],
-                filters: [],
-                sorting: def.sorting ?? [],
-            });
-        }
-        else {
-            rawDef = this.patchPTableDef(def);
-        }
-        const columns = extractAllColumns(rawDef.src);
-        this.verifyInlineAndExplicitColumnsSupport(columns);
-        if (!allPColumnsReady(columns))
-            return undefined;
-        return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
-    }
-    createPTableV2(def) {
-        const columns = collectSpecQueryColumns(def.query);
-        this.verifyInlineAndExplicitColumnsSupport(columns);
-        if (!allPColumnsReady(columns))
-            return undefined;
-        return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));
-    }
-    /** @deprecated scheduled for removal from SDK */
-    getBlockLabel(blockId) {
-        return this.ctx.getBlockLabel(blockId);
-    }
-    getCurrentUnstableMarker() {
-        return this.ctx.getCurrentUnstableMarker();
-    }
-    logInfo(msg) {
-        this.ctx.logInfo(msg);
-    }
-    logWarn(msg) {
-        this.ctx.logWarn(msg);
-    }
-    logError(msg) {
-        this.ctx.logError(msg);
-    }
-}
+var RenderCtxBase = class {
+	ctx;
+	constructor() {
+		this.ctx = getCfgRenderCtx();
+	}
+	dataCache;
+	get data() {
+		if (this.dataCache === void 0) {
+			const raw = this.ctx.data;
+			const value = typeof raw === "function" ? raw() : raw;
+			this.dataCache = { v: value ? JSON.parse(value) : {} };
+		}
+		return this.dataCache.v;
+	}
+	activeArgsCache;
+	/**
+	* Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
+	* Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.
+	* */
+	get activeArgs() {
+		if (this.activeArgsCache === void 0) {
+			const raw = this.ctx.activeArgs;
+			const value = typeof raw === "function" ? raw() : raw;
+			this.activeArgsCache = { v: value ? JSON.parse(value) : void 0 };
+		}
+		return this.activeArgsCache.v;
+	}
+	getNamedAccessor(name) {
+		return ifDef(this.ctx.getAccessorHandleByName(name), (accessor) => new TreeNodeAccessor(accessor, [name]));
+	}
+	get prerun() {
+		return this.getNamedAccessor(StagingAccessorName);
+	}
+	get outputs() {
+		return this.getNamedAccessor(MainAccessorName);
+	}
+	resultPool = new ResultPool();
+	/**
+	* Find labels data for a given axis id. It will search for a label column and return its data as a map.
+	* @returns a map of axis value => label
+	* @deprecated Use resultPool.findLabels instead
+	*/
+	findLabels(axis) {
+		return this.resultPool.findLabels(axis);
+	}
+	verifyInlineAndExplicitColumnsSupport(columns) {
+		const hasInlineColumns = columns.some((c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data));
+		const inlineColumnsSupport = this.ctx.featureFlags?.inlineColumnsSupport === true;
+		if (hasInlineColumns && !inlineColumnsSupport) throw Error(`Inline or explicit columns not supported`);
+	}
+	patchPTableDef(def) {
+		if (!this.ctx.featureFlags?.pTablePartitionFiltersSupport) def = {
+			...def,
+			partitionFilters: [],
+			filters: [...def.partitionFilters, ...def.filters]
+		};
+		if (!this.ctx.featureFlags?.pFrameInSetFilterSupport) def = {
+			...def,
+			partitionFilters: patchInSetFilters(def.partitionFilters),
+			filters: patchInSetFilters(def.filters)
+		};
+		return def;
+	}
+	createPFrame(def) {
+		this.verifyInlineAndExplicitColumnsSupport(def);
+		if (!allPColumnsReady(def)) return void 0;
+		return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
+	}
+	createPTable(def) {
+		let rawDef;
+		if ("columns" in def) rawDef = this.patchPTableDef({
+			src: {
+				type: "full",
+				entries: def.columns.map((c) => ({
+					type: "column",
+					column: c
+				}))
+			},
+			partitionFilters: def.filters ?? [],
+			filters: [],
+			sorting: def.sorting ?? []
+		});
+		else rawDef = this.patchPTableDef(def);
+		const columns = extractAllColumns(rawDef.src);
+		this.verifyInlineAndExplicitColumnsSupport(columns);
+		if (!allPColumnsReady(columns)) return void 0;
+		return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
+	}
+	createPTableV2(def) {
+		const columns = collectSpecQueryColumns(def.query);
+		this.verifyInlineAndExplicitColumnsSupport(columns);
+		if (!allPColumnsReady(columns)) return void 0;
+		return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));
+	}
+	/** @deprecated scheduled for removal from SDK */
+	getBlockLabel(blockId) {
+		return this.ctx.getBlockLabel(blockId);
+	}
+	getCurrentUnstableMarker() {
+		return this.ctx.getCurrentUnstableMarker();
+	}
+	logInfo(msg) {
+		this.ctx.logInfo(msg);
+	}
+	logWarn(msg) {
+		this.ctx.logWarn(msg);
+	}
+	logError(msg) {
+		this.ctx.logError(msg);
+	}
+};
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */
-class BlockRenderCtx extends RenderCtxBase {
-    argsCache;
-    get args() {
-        if (this.argsCache === undefined) {
-            const raw = this.ctx.args;
-            const value = typeof raw === "function" ? raw() : raw;
-            this.argsCache = { v: value === undefined ? undefined : JSON.parse(value) };
-        }
-        return this.argsCache.v;
-    }
-}
+var BlockRenderCtx = class extends RenderCtxBase {
+	argsCache;
+	get args() {
+		if (this.argsCache === void 0) {
+			const raw = this.ctx.args;
+			const value = typeof raw === "function" ? raw() : raw;
+			this.argsCache = { v: value === void 0 ? void 0 : JSON.parse(value) };
+		}
+		return this.argsCache.v;
+	}
+};
 /** Render context for legacy v1/v2 blocks - provides backward compatibility */
-class RenderCtxLegacy extends RenderCtxBase {
-    argsCache;
-    get args() {
-        if (this.argsCache === undefined) {
-            const raw = this.ctx.args;
-            const value = typeof raw === "function" ? raw() : raw;
-            this.argsCache = { v: JSON.parse(value) };
-        }
-        return this.argsCache.v;
-    }
-    uiStateCache;
-    get uiState() {
-        if (this.uiStateCache === undefined) {
-            const raw = this.ctx.uiState;
-            const value = typeof raw === "function" ? raw() : raw;
-            this.uiStateCache = { v: value ? JSON.parse(value) : {} };
-        }
-        return this.uiStateCache.v;
-    }
-}
+var RenderCtxLegacy = class extends RenderCtxBase {
+	argsCache;
+	get args() {
+		if (this.argsCache === void 0) {
+			const raw = this.ctx.args;
+			const value = typeof raw === "function" ? raw() : raw;
+			this.argsCache = { v: JSON.parse(value) };
+		}
+		return this.argsCache.v;
+	}
+	uiStateCache;
+	get uiState() {
+		if (this.uiStateCache === void 0) {
+			const raw = this.ctx.uiState;
+			const value = typeof raw === "function" ? raw() : raw;
+			this.uiStateCache = { v: value ? JSON.parse(value) : {} };
+		}
+		return this.uiStateCache.v;
+	}
+};
 /**
- * Render context for plugin output functions.
- * Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.
- *
- * Parameterized on the factory-like phantom F so that getPluginData returns
- * InferFactoryData<F> directly — no casts needed for the data getter.
- *
- * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
- */
-class PluginRenderCtx {
-    ctx;
-    handle;
-    wrappedInputs;
-    constructor(handle, wrappedInputs) {
-        this.ctx = getCfgRenderCtx();
-        this.handle = handle;
-        this.wrappedInputs = wrappedInputs;
-    }
-    dataCache;
-    /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
-    get data() {
-        if (this.dataCache === undefined) {
-            const raw = this.ctx.blockStorage();
-            this.dataCache = { v: getPluginData(parseJson(raw), this.handle) };
-        }
-        return this.dataCache.v;
-    }
-    paramsCache;
-    /** Params derived from block context via pre-wrapped input callbacks */
-    get params() {
-        if (this.paramsCache === undefined) {
-            const result = {};
-            for (const [key, fn] of Object.entries(this.wrappedInputs)) {
-                result[key] = fn();
-            }
-            this.paramsCache = { v: result };
-        }
-        return this.paramsCache.v;
-    }
-    /** Result pool — same as block, from cfgRenderCtx methods */
-    resultPool = new ResultPool();
-}
+* Render context for plugin output functions.
+* Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.
+*
+* Parameterized on the factory-like phantom F so that getPluginData returns
+* InferFactoryData<F> directly — no casts needed for the data getter.
+*
+* @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
+*/
+var PluginRenderCtx = class {
+	ctx;
+	handle;
+	wrappedInputs;
+	constructor(handle, wrappedInputs) {
+		this.ctx = getCfgRenderCtx();
+		this.handle = handle;
+		this.wrappedInputs = wrappedInputs;
+	}
+	dataCache;
+	/** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
+	get data() {
+		if (this.dataCache === void 0) this.dataCache = { v: getPluginData(parseJson(this.ctx.blockStorage()), this.handle) };
+		return this.dataCache.v;
+	}
+	paramsCache;
+	/** Params derived from block context via pre-wrapped input callbacks */
+	get params() {
+		if (this.paramsCache === void 0) {
+			const result = {};
+			for (const [key, fn] of Object.entries(this.wrappedInputs)) result[key] = fn();
+			this.paramsCache = { v: result };
+		}
+		return this.paramsCache.v;
+	}
+	/** Result pool — same as block, from cfgRenderCtx methods */
+	resultPool = new ResultPool();
+};
 
+//#endregion
 export { BlockRenderCtx, PluginRenderCtx, RenderCtxBase, RenderCtxLegacy, ResultPool };
-//# sourceMappingURL=api.js.map
+//# sourceMappingURL=api.js.map