@platforma-sdk/model 1.58.5 → 1.58.9

package/dist/pframe_utils/index.d.ts

@@ -1,48 +1,52 @@
-import type { PColumnSpec, PFrameHandle, AxisId, CanonicalizedJson, FindColumnsRequest, PColumnIdAndSpec, PObjectId, PTableRecordSingleValueFilterV2, ValueType } from "@milaboratories/pl-model-common";
-export * from "./columns";
+import { getAllRelatedColumns, getRelatedColumns } from "./columns.js";
+import { AxisId, CanonicalizedJson, FindColumnsRequest, PColumnIdAndSpec, PColumnSpec, PFrameHandle, PObjectId, PTableRecordSingleValueFilterV2, ValueType } from "@milaboratories/pl-model-common";
+
+//#region src/pframe_utils/index.d.ts
 type PValue = string | number | null;
 type SuggestionResponse = {
-    values: {
-        value: string;
-        label: string;
-    }[];
-    overflow: boolean;
+  values: {
+    value: string;
+    label: string;
+  }[];
+  overflow: boolean;
 };
 type SingleColumnData = {
-    axesData: Record<string, PValue[]>;
-    data: PValue[];
+  axesData: Record<string, PValue[]>;
+  data: PValue[];
 };
-type UniqueValuesResponse = {
-    values: string[];
-    overflow: boolean;
+type UniqueValuesResponse$1 = {
+  values: string[];
+  overflow: boolean;
 };
 type GetUniqueSourceValuesParams = {
-    columnId: PObjectId;
-    axisIdx?: number;
-    limit?: number;
-    searchQuery?: string;
-    searchQueryValue?: string;
+  columnId: PObjectId;
+  axisIdx?: number;
+  limit?: number;
+  searchQuery?: string;
+  searchQueryValue?: string;
 };
 type GetAxisUniqueValuesParams = {
-    axisId: AxisId;
-    parentColumnIds: PObjectId[];
-    limit?: number;
-    filters?: PTableRecordSingleValueFilterV2[];
+  axisId: AxisId;
+  parentColumnIds: PObjectId[];
+  limit?: number;
+  filters?: PTableRecordSingleValueFilterV2[];
 };
 type GetColumnsFullParams = {
-    selectedSources: PObjectId[];
-    strictlyCompatible: boolean;
-    types?: ValueType[];
-    names?: string[];
-    annotations?: FindColumnsRequest["columnFilter"]["annotationValue"];
-    annotationsNotEmpty?: string[];
+  selectedSources: PObjectId[];
+  strictlyCompatible: boolean;
+  types?: ValueType[];
+  names?: string[];
+  annotations?: FindColumnsRequest["columnFilter"]["annotationValue"];
+  annotationsNotEmpty?: string[];
 };
-export declare function getColumnSpecById(handle: PFrameHandle, id: PObjectId): Promise<PColumnSpec | null>;
-export declare function getSingleColumnData(handle: PFrameHandle, id: PObjectId, filters?: PTableRecordSingleValueFilterV2[]): Promise<SingleColumnData>;
-export declare function getColumnUniqueValues(handle: PFrameHandle, id: PObjectId, limit?: number, filters?: PTableRecordSingleValueFilterV2[]): Promise<UniqueValuesResponse>;
-export declare function getAxisUniqueValues(handle: PFrameHandle, params: GetAxisUniqueValuesParams): Promise<UniqueValuesResponse>;
-export declare function getRequestColumnsFromSelectedSources(handle: PFrameHandle, sources: PObjectId[]): Promise<AxisId[]>;
-export declare function getColumnsFull(handle: PFrameHandle, params: GetColumnsFullParams): Promise<PColumnIdAndSpec[]>;
-export declare function getColumnOrAxisValueLabelsId(handle: PFrameHandle, strAxisId: CanonicalizedJson<AxisId>): Promise<PObjectId | undefined>;
-export declare function getUniqueSourceValuesWithLabels(handle: PFrameHandle, params: GetUniqueSourceValuesParams): Promise<SuggestionResponse>;
+declare function getColumnSpecById(handle: PFrameHandle, id: PObjectId): Promise<PColumnSpec | null>;
+declare function getSingleColumnData(handle: PFrameHandle, id: PObjectId, filters?: PTableRecordSingleValueFilterV2[]): Promise<SingleColumnData>;
+declare function getColumnUniqueValues(handle: PFrameHandle, id: PObjectId, limit?: number, filters?: PTableRecordSingleValueFilterV2[]): Promise<UniqueValuesResponse$1>;
+declare function getAxisUniqueValues(handle: PFrameHandle, params: GetAxisUniqueValuesParams): Promise<UniqueValuesResponse$1>;
+declare function getRequestColumnsFromSelectedSources(handle: PFrameHandle, sources: PObjectId[]): Promise<AxisId[]>;
+declare function getColumnsFull(handle: PFrameHandle, params: GetColumnsFullParams): Promise<PColumnIdAndSpec[]>;
+declare function getColumnOrAxisValueLabelsId(handle: PFrameHandle, strAxisId: CanonicalizedJson<AxisId>): Promise<PObjectId | undefined>;
+declare function getUniqueSourceValuesWithLabels(handle: PFrameHandle, params: GetUniqueSourceValuesParams): Promise<SuggestionResponse>;
+//#endregion
+export { getAxisUniqueValues, getColumnOrAxisValueLabelsId, getColumnSpecById, getColumnUniqueValues, getColumnsFull, getRequestColumnsFromSelectedSources, getSingleColumnData, getUniqueSourceValuesWithLabels };
 //# sourceMappingURL=index.d.ts.map

package/dist/pframe_utils/index.js

@@ -1,287 +1,267 @@
-import { uniq, flatten } from 'es-toolkit';
-import { getAxisId, canonicalizeAxisId, PColumnName, pTableValue, readAnnotation, Annotation } from '@milaboratories/pl-model-common';
-import 'canonicalize';
-import '../render/util/label.js';
+import { getAllRelatedColumns, getRelatedColumns } from "./columns.js";
+import { Annotation, PColumnName, canonicalizeAxisId, getAxisId, pTableValue, readAnnotation } from "@milaboratories/pl-model-common";
+import { flatten, uniq } from "es-toolkit";
 
-// Constants
-const UNIQUE_VALUES_LIMIT = 1000000;
-// Helper functions
+//#region src/pframe_utils/index.ts
+const UNIQUE_VALUES_LIMIT = 1e6;
 const sortValuesPredicate = (a, b) => a.label.localeCompare(b.label, "en", { numeric: true });
 function convertColumnData(type, response, absentValue = null) {
-    if (type === "String") {
-        return response.data;
-    }
-    const res = new Array(response.data.length);
-    for (let i = 0; i < response.data.length; i++) {
-        res[i] = pTableValue(response, i, { absent: absentValue, na: null });
-    }
-    return res;
+	if (type === "String") return response.data;
+	const res = new Array(response.data.length);
+	for (let i = 0; i < response.data.length; i++) res[i] = pTableValue(response, i, {
+		absent: absentValue,
+		na: null
+	});
+	return res;
 }
 function createSearchFilter(columnId, substring) {
-    return {
-        type: "bySingleColumnV2",
-        column: {
-            type: "column",
-            id: columnId,
-        },
-        predicate: {
-            operator: "StringIContains",
-            substring,
-        },
-    };
+	return {
+		type: "bySingleColumnV2",
+		column: {
+			type: "column",
+			id: columnId
+		},
+		predicate: {
+			operator: "StringIContains",
+			substring
+		}
+	};
 }
 function createAxisSearchFilter(axisSpec, substring) {
-    return {
-        type: "bySingleColumnV2",
-        column: {
-            type: "axis",
-            id: {
-                type: axisSpec.type,
-                name: axisSpec.name,
-            },
-        },
-        predicate: {
-            operator: "StringIContains",
-            substring,
-        },
-    };
+	return {
+		type: "bySingleColumnV2",
+		column: {
+			type: "axis",
+			id: {
+				type: axisSpec.type,
+				name: axisSpec.name
+			}
+		},
+		predicate: {
+			operator: "StringIContains",
+			substring
+		}
+	};
 }
 function mapValuesToSuggestions(values) {
-    return values.map((v) => ({ value: String(v), label: String(v) })).sort(sortValuesPredicate);
+	return values.map((v) => ({
+		value: String(v),
+		label: String(v)
+	})).sort(sortValuesPredicate);
 }
 function getPFrameDriver() {
-    if (typeof platforma === "undefined") {
-        throw new Error("Platforma instance is not available");
-    }
-    if (typeof platforma.pFrameDriver === "undefined") {
-        throw new Error("PFrame driver is not available in the current Platforma instance");
-    }
-    return platforma.pFrameDriver;
+	if (typeof platforma === "undefined") throw new Error("Platforma instance is not available");
+	if (typeof platforma.pFrameDriver === "undefined") throw new Error("PFrame driver is not available in the current Platforma instance");
+	return platforma.pFrameDriver;
 }
-// Core functions
 async function getColumnSpecById(handle, id) {
-    try {
-        const response = await getPFrameDriver().getColumnSpec(handle, id);
-        return response ?? null;
-    }
-    catch (err) {
-        console.error("PFrame: get single column error", err);
-        return null;
-    }
+	try {
+		return await getPFrameDriver().getColumnSpec(handle, id) ?? null;
+	} catch (err) {
+		console.error("PFrame: get single column error", err);
+		return null;
+	}
 }
 async function getSingleColumnData(handle, id, filters = []) {
-    try {
-        const response = await getPFrameDriver().calculateTableData(handle, {
-            src: {
-                type: "column",
-                column: id,
-            },
-            filters,
-            sorting: [],
-        });
-        const axes = response.filter((item) => item.spec.type === "axis");
-        const columns = response.filter((item) => item.spec.type === "column");
-        return {
-            axesData: axes.reduce((res, item) => {
-                const id = getAxisId(item.spec.spec);
-                res[canonicalizeAxisId(id)] = convertColumnData(id.type, item.data);
-                return res;
-            }, {}),
-            data: columns.length ? convertColumnData(columns[0].data.type, columns[0].data) : [],
-        };
-    }
-    catch (err) {
-        console.error("PFrame: calculateTableData error");
-        throw err;
-    }
+	try {
+		const response = await getPFrameDriver().calculateTableData(handle, {
+			src: {
+				type: "column",
+				column: id
+			},
+			filters,
+			sorting: []
+		});
+		const axes = response.filter((item) => item.spec.type === "axis");
+		const columns = response.filter((item) => item.spec.type === "column");
+		return {
+			axesData: axes.reduce((res, item) => {
+				const id = getAxisId(item.spec.spec);
+				res[canonicalizeAxisId(id)] = convertColumnData(id.type, item.data);
+				return res;
+			}, {}),
+			data: columns.length ? convertColumnData(columns[0].data.type, columns[0].data) : []
+		};
+	} catch (err) {
+		console.error("PFrame: calculateTableData error");
+		throw err;
+	}
 }
 async function getColumnUniqueValues(handle, id, limit = UNIQUE_VALUES_LIMIT, filters = []) {
-    const request = {
-        columnId: id,
-        filters,
-        limit,
-    };
-    try {
-        const response = await getPFrameDriver().getUniqueValues(handle, request);
-        if (response.overflow) {
-            console.warn(`More than ${limit} values for ${id} column`);
-        }
-        return {
-            values: Array.from(response.values.data).map(String),
-            overflow: response.overflow,
-        };
-    }
-    catch (err) {
-        console.error("PFrame: getUniqueValues for column error");
-        throw err;
-    }
+	const request = {
+		columnId: id,
+		filters,
+		limit
+	};
+	try {
+		const response = await getPFrameDriver().getUniqueValues(handle, request);
+		if (response.overflow) console.warn(`More than ${limit} values for ${id} column`);
+		return {
+			values: Array.from(response.values.data).map(String),
+			overflow: response.overflow
+		};
+	} catch (err) {
+		console.error("PFrame: getUniqueValues for column error");
+		throw err;
+	}
 }
 async function getAxisUniqueValues(handle, params) {
-    const { axisId, parentColumnIds, limit = UNIQUE_VALUES_LIMIT, filters = [] } = params;
-    const strAxisId = canonicalizeAxisId(axisId);
-    const parentsSpecs = (await Promise.all(parentColumnIds.map((p) => getColumnSpecById(handle, p))))
-        .flatMap((spec, i) => spec != null && spec.kind === "PColumn" ? [[parentColumnIds[i], spec]] : [])
-        .filter(([_, spec]) => spec.axesSpec.some((axisSpec) => canonicalizeAxisId(getAxisId(axisSpec)) === strAxisId));
-    if (parentsSpecs.length === 0) {
-        console.warn("Axis unique values requested without parent columns");
-        return { values: [], overflow: false };
-    }
-    try {
-        const responses = await Promise.all(parentsSpecs.map(([id]) => getPFrameDriver().getUniqueValues(handle, {
-            columnId: id,
-            axis: axisId,
-            filters,
-            limit,
-        })));
-        const overflow = responses.some((r) => r.overflow);
-        return {
-            values: uniq(flatten(responses.map((r) => Array.from(r.values.data).map(String)))),
-            overflow,
-        };
-    }
-    catch (err) {
-        console.error("PFrame: getUniqueValues for axis error", err);
-        return { values: [], overflow: false };
-    }
+	const { axisId, parentColumnIds, limit = UNIQUE_VALUES_LIMIT, filters = [] } = params;
+	const strAxisId = canonicalizeAxisId(axisId);
+	const parentsSpecs = (await Promise.all(parentColumnIds.map((p) => getColumnSpecById(handle, p)))).flatMap((spec, i) => spec != null && spec.kind === "PColumn" ? [[parentColumnIds[i], spec]] : []).filter(([_, spec]) => spec.axesSpec.some((axisSpec) => canonicalizeAxisId(getAxisId(axisSpec)) === strAxisId));
+	if (parentsSpecs.length === 0) {
+		console.warn("Axis unique values requested without parent columns");
+		return {
+			values: [],
+			overflow: false
+		};
+	}
+	try {
+		const responses = await Promise.all(parentsSpecs.map(([id]) => getPFrameDriver().getUniqueValues(handle, {
+			columnId: id,
+			axis: axisId,
+			filters,
+			limit
+		})));
+		const overflow = responses.some((r) => r.overflow);
+		return {
+			values: uniq(flatten(responses.map((r) => Array.from(r.values.data).map(String)))),
+			overflow
+		};
+	} catch (err) {
+		console.error("PFrame: getUniqueValues for axis error", err);
+		return {
+			values: [],
+			overflow: false
+		};
+	}
 }
 async function getRequestColumnsFromSelectedSources(handle, sources) {
-    const result = [];
-    for (const item of sources) {
-        const spec = await getColumnSpecById(handle, item);
-        if (spec?.kind === "PColumn") {
-            result.push(...spec.axesSpec.map((spec) => getAxisId(spec)));
-        }
-    }
-    return result;
+	const result = [];
+	for (const item of sources) {
+		const spec = await getColumnSpecById(handle, item);
+		if (spec?.kind === "PColumn") result.push(...spec.axesSpec.map((spec) => getAxisId(spec)));
+	}
+	return result;
 }
 async function getColumnsFull(handle, params) {
-    const { selectedSources, strictlyCompatible, types, names, annotations, annotationsNotEmpty } = params;
-    try {
-        const request = {
-            columnFilter: {
-                type: types,
-                name: names,
-                annotationValue: annotations,
-                annotationPattern: annotationsNotEmpty?.reduce((res, v) => {
-                    res[v] = ".+";
-                    return res;
-                }, {}),
-            },
-            compatibleWith: await getRequestColumnsFromSelectedSources(handle, selectedSources),
-            strictlyCompatible,
-        };
-        const response = await getPFrameDriver().findColumns(handle, request);
-        return response.hits;
-    }
-    catch (err) {
-        console.error("PFrame: findColumns error");
-        throw err;
-    }
+	const { selectedSources, strictlyCompatible, types, names, annotations, annotationsNotEmpty } = params;
+	try {
+		const request = {
+			columnFilter: {
+				type: types,
+				name: names,
+				annotationValue: annotations,
+				annotationPattern: annotationsNotEmpty?.reduce((res, v) => {
+					res[v] = ".+";
+					return res;
+				}, {})
+			},
+			compatibleWith: await getRequestColumnsFromSelectedSources(handle, selectedSources),
+			strictlyCompatible
+		};
+		return (await getPFrameDriver().findColumns(handle, request)).hits;
+	} catch (err) {
+		console.error("PFrame: findColumns error");
+		throw err;
+	}
 }
 async function getColumnOrAxisValueLabelsId(handle, strAxisId) {
-    const labelColumns = await getColumnsFull(handle, {
-        selectedSources: [],
-        strictlyCompatible: false,
-        names: [PColumnName.Label],
-    });
-    const labelColumn = labelColumns.find(({ spec }) => {
-        return spec && spec.axesSpec.length === 1 && canonicalizeAxisId(spec.axesSpec[0]) === strAxisId;
-    });
-    return labelColumn?.columnId;
+	return (await getColumnsFull(handle, {
+		selectedSources: [],
+		strictlyCompatible: false,
+		names: [PColumnName.Label]
+	})).find(({ spec }) => {
+		return spec && spec.axesSpec.length === 1 && canonicalizeAxisId(spec.axesSpec[0]) === strAxisId;
+	})?.columnId;
 }
 function getDiscreteValuesFromAnnotation(columnSpec) {
-    const discreteValuesStr = readAnnotation(columnSpec, Annotation.DiscreteValues);
-    if (!discreteValuesStr) {
-        return undefined;
-    }
-    try {
-        const discreteValues = JSON.parse(discreteValuesStr).map((v) => String(v));
-        const values = discreteValues.map((v) => ({ value: v, label: v })).sort(sortValuesPredicate);
-        return { values, overflow: false };
-    }
-    catch {
-        console.error(`Parsing error: discrete values annotation ${discreteValuesStr}`);
-        return undefined;
-    }
+	const discreteValuesStr = readAnnotation(columnSpec, Annotation.DiscreteValues);
+	if (!discreteValuesStr) return;
+	try {
+		return {
+			values: JSON.parse(discreteValuesStr).map((v) => String(v)).map((v) => ({
+				value: v,
+				label: v
+			})).sort(sortValuesPredicate),
+			overflow: false
+		};
+	} catch {
+		console.error(`Parsing error: discrete values annotation ${discreteValuesStr}`);
+		return;
+	}
 }
 async function getAxisValuesWithLabels(handle, params) {
-    const { columnId, axisSpec, labelsColumnId, limit, searchQuery, searchQueryValue } = params;
-    const strAxisId = canonicalizeAxisId(getAxisId(axisSpec));
-    let filters = [];
-    if (labelsColumnId) {
-        if (searchQuery) {
-            filters = [createSearchFilter(labelsColumnId, searchQuery)];
-        }
-        if (searchQueryValue) {
-            filters = [createAxisSearchFilter(axisSpec, searchQueryValue)];
-        }
-        const { data: dataValues, axesData } = await getSingleColumnData(handle, labelsColumnId, filters);
-        const axisKeys = axesData[strAxisId];
-        const values = [];
-        for (let i = 0; i < Math.min(axisKeys.length, limit ?? axisKeys.length); i++) {
-            values.push({ value: String(axisKeys[i]), label: String(dataValues[i]) });
-        }
-        values.sort(sortValuesPredicate);
-        return { values, overflow: !(limit === undefined || axisKeys.length < limit) };
-    }
-    else {
-        const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
-        if (searchInLabelsOrValue) {
-            filters = [createAxisSearchFilter(axisSpec, searchInLabelsOrValue)];
-        }
-        const response = await getAxisUniqueValues(handle, {
-            axisId: getAxisId(axisSpec),
-            parentColumnIds: [columnId],
-            limit,
-            filters,
-        });
-        const values = mapValuesToSuggestions(response.values);
-        return { values, overflow: response.overflow };
-    }
+	const { columnId, axisSpec, labelsColumnId, limit, searchQuery, searchQueryValue } = params;
+	const strAxisId = canonicalizeAxisId(getAxisId(axisSpec));
+	let filters = [];
+	if (labelsColumnId) {
+		if (searchQuery) filters = [createSearchFilter(labelsColumnId, searchQuery)];
+		if (searchQueryValue) filters = [createAxisSearchFilter(axisSpec, searchQueryValue)];
+		const { data: dataValues, axesData } = await getSingleColumnData(handle, labelsColumnId, filters);
+		const axisKeys = axesData[strAxisId];
+		const values = [];
+		for (let i = 0; i < Math.min(axisKeys.length, limit ?? axisKeys.length); i++) values.push({
+			value: String(axisKeys[i]),
+			label: String(dataValues[i])
+		});
+		values.sort(sortValuesPredicate);
+		return {
+			values,
+			overflow: !(limit === void 0 || axisKeys.length < limit)
+		};
+	} else {
+		const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
+		if (searchInLabelsOrValue) filters = [createAxisSearchFilter(axisSpec, searchInLabelsOrValue)];
+		const response = await getAxisUniqueValues(handle, {
+			axisId: getAxisId(axisSpec),
+			parentColumnIds: [columnId],
+			limit,
+			filters
+		});
+		return {
+			values: mapValuesToSuggestions(response.values),
+			overflow: response.overflow
+		};
+	}
 }
 async function getColumnValuesWithLabels(handle, params) {
-    const { columnId, limit, searchQuery, searchQueryValue } = params;
-    const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
-    const filters = searchInLabelsOrValue
-        ? [createSearchFilter(columnId, searchInLabelsOrValue)]
-        : [];
-    const response = await getColumnUniqueValues(handle, columnId, limit, filters);
-    const values = mapValuesToSuggestions(response.values);
-    return { values, overflow: response.overflow };
+	const { columnId, limit, searchQuery, searchQueryValue } = params;
+	const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
+	const response = await getColumnUniqueValues(handle, columnId, limit, searchInLabelsOrValue ? [createSearchFilter(columnId, searchInLabelsOrValue)] : []);
+	return {
+		values: mapValuesToSuggestions(response.values),
+		overflow: response.overflow
+	};
 }
 async function getUniqueSourceValuesWithLabels(handle, params) {
-    const { columnId, axisIdx, limit, searchQuery, searchQueryValue } = params;
-    const selectedSourceSpec = await getColumnSpecById(handle, columnId);
-    if (selectedSourceSpec == null || selectedSourceSpec.kind !== "PColumn") {
-        return { values: [], overflow: false };
-    }
-    // Try to get discrete values from annotation
-    const discreteValues = getDiscreteValuesFromAnnotation(selectedSourceSpec);
-    if (discreteValues != null) {
-        return discreteValues;
-    }
-    // Handle axis values
-    if (axisIdx != null) {
-        const axisSpec = selectedSourceSpec.axesSpec[axisIdx];
-        const strAxisId = canonicalizeAxisId(getAxisId(axisSpec));
-        const labelsColumnId = await getColumnOrAxisValueLabelsId(handle, strAxisId);
-        return getAxisValuesWithLabels(handle, {
-            columnId,
-            axisSpec,
-            labelsColumnId,
-            limit,
-            searchQuery,
-            searchQueryValue,
-        });
-    }
-    // Handle column values
-    return getColumnValuesWithLabels(handle, {
-        columnId,
-        limit,
-        searchQuery,
-        searchQueryValue,
-    });
+	const { columnId, axisIdx, limit, searchQuery, searchQueryValue } = params;
+	const selectedSourceSpec = await getColumnSpecById(handle, columnId);
+	if (selectedSourceSpec == null || selectedSourceSpec.kind !== "PColumn") return {
+		values: [],
+		overflow: false
+	};
+	const discreteValues = getDiscreteValuesFromAnnotation(selectedSourceSpec);
+	if (discreteValues != null) return discreteValues;
+	if (axisIdx != null) {
+		const axisSpec = selectedSourceSpec.axesSpec[axisIdx];
+		return getAxisValuesWithLabels(handle, {
+			columnId,
+			axisSpec,
+			labelsColumnId: await getColumnOrAxisValueLabelsId(handle, canonicalizeAxisId(getAxisId(axisSpec))),
+			limit,
+			searchQuery,
+			searchQueryValue
+		});
+	}
+	return getColumnValuesWithLabels(handle, {
+		columnId,
+		limit,
+		searchQuery,
+		searchQueryValue
+	});
 }
 
+//#endregion
 export { getAxisUniqueValues, getColumnOrAxisValueLabelsId, getColumnSpecById, getColumnUniqueValues, getColumnsFull, getRequestColumnsFromSelectedSources, getSingleColumnData, getUniqueSourceValuesWithLabels };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map