@milaboratories/pl-model-common 1.25.1 → 1.25.3

package/dist/drivers/pframe/spec/spec.cjs

@@ -1,414 +1,372 @@
-'use strict';
-
-var errors = require('../../../errors.cjs');
-var json = require('../../../json.cjs');
-var zod = require('zod');
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+const require_errors = require('../../../errors.cjs');
+const require_json = require('../../../json.cjs');
+let zod = require("zod");
 
+//#region src/drivers/pframe/spec/spec.ts
 const ValueType = {
-    Int: "Int",
-    Long: "Long",
-    Float: "Float",
-    Double: "Double",
-    String: "String",
-    Bytes: "Bytes",
+	Int: "Int",
+	Long: "Long",
+	Float: "Float",
+	Double: "Double",
+	String: "String",
+	Bytes: "Bytes"
 };
 function readMetadata(metadata, key) {
-    return metadata?.[key];
+	return metadata?.[key];
 }
 function readMetadataJsonOrThrow(metadata, metadataJson, key, methodNameInError = "readMetadataJsonOrThrow") {
-    const json = readMetadata(metadata, key);
-    if (json === undefined)
-        return undefined;
-    const schema = metadataJson[key];
-    try {
-        const value = JSON.parse(json);
-        return schema.parse(value);
-    }
-    catch (error) {
-        throw new Error(`${methodNameInError} failed, ` +
-            `key: ${String(key)}, ` +
-            `value: ${json}, ` +
-            `error: ${errors.ensureError(error)}`);
-    }
+	const json = readMetadata(metadata, key);
+	if (json === void 0) return void 0;
+	const schema = metadataJson[key];
+	try {
+		const value = JSON.parse(json);
+		return schema.parse(value);
+	} catch (error) {
+		throw new Error(`${methodNameInError} failed, key: ${String(key)}, value: ${json}, error: ${require_errors.ensureError(error)}`);
+	}
 }
 function readMetadataJson(metadata, metadataJson, key) {
-    try {
-        return readMetadataJsonOrThrow(metadata, metadataJson, key);
-    }
-    catch {
-        return undefined; // treat invalid values as unset
-    }
+	try {
+		return readMetadataJsonOrThrow(metadata, metadataJson, key);
+	} catch {
+		return;
+	}
 }
-/// Well-known domains
 const Domain = {
-    Alphabet: "pl7.app/alphabet",
-    BlockId: "pl7.app/blockId",
-    VDJ: {
-        Clustering: {
-            BlockId: "pl7.app/vdj/clustering/blockId",
-        },
-        ScClonotypeChain: {
-            Index: "pl7.app/vdj/scClonotypeChain/index",
-        },
-    },
+	Alphabet: "pl7.app/alphabet",
+	BlockId: "pl7.app/blockId",
+	VDJ: {
+		Clustering: { BlockId: "pl7.app/vdj/clustering/blockId" },
+		ScClonotypeChain: { Index: "pl7.app/vdj/scClonotypeChain/index" }
+	}
 };
 const DomainJson = {};
-/// Helper function for reading plain domain values
 function readDomain(spec, key) {
-    return readMetadata(spec?.domain, key);
+	return readMetadata(spec?.domain, key);
 }
-/// Helper function for reading json-encoded domain values, throws on JSON parsing error
 function readDomainJsonOrThrow(spec, key) {
-    return readMetadataJsonOrThrow(spec?.domain, DomainJson, key, "readDomainJsonOrThrow");
+	return readMetadataJsonOrThrow(spec?.domain, DomainJson, key, "readDomainJsonOrThrow");
 }
-/// Helper function for reading json-encoded domain values, returns undefined on JSON parsing error
 function readDomainJson(spec, key) {
-    return readMetadataJson(spec?.domain, DomainJson, key);
+	return readMetadataJson(spec?.domain, DomainJson, key);
 }
-/// Well-known annotations
 const Annotation = {
-    AxisNature: "pl7.app/axisNature",
-    Alphabet: "pl7.app/alphabet",
-    Description: "pl7.app/description",
-    DiscreteValues: "pl7.app/discreteValues",
-    Format: "pl7.app/format",
-    Graph: {
-        Axis: {
-            HighCardinality: "pl7.app/graph/axis/highCardinality",
-            LowerLimit: "pl7.app/graph/axis/lowerLimit",
-            SymmetricRange: "pl7.app/graph/axis/symmetricRange",
-            UpperLimit: "pl7.app/graph/axis/upperLimit",
-        },
-        IsDenseAxis: "pl7.app/graph/isDenseAxis",
-        IsVirtual: "pl7.app/graph/isVirtual",
-        Palette: "pl7.app/graph/palette",
-        Thresholds: "pl7.app/graph/thresholds",
-        TreatAbsentValuesAs: "pl7.app/graph/treatAbsentValuesAs",
-    },
-    HideDataFromUi: "pl7.app/hideDataFromUi",
-    HideDataFromGraphs: "pl7.app/hideDataFromGraphs",
-    IsDiscreteFilter: "pl7.app/isDiscreteFilter",
-    IsAnchor: "pl7.app/isAnchor",
-    IsLinkerColumn: "pl7.app/isLinkerColumn",
-    IsScore: "pl7.app/isScore",
-    IsSubset: "pl7.app/isSubset",
-    Label: "pl7.app/label",
-    Max: "pl7.app/max",
-    Min: "pl7.app/min",
-    MultipliesBy: "pl7.app/multipliesBy",
-    Parents: "pl7.app/parents",
-    Score: {
-        DefaultCutoff: "pl7.app/score/defaultCutoff",
-        RankingOrder: "pl7.app/score/rankingOrder",
-    },
-    Sequence: {
-        Annotation: {
-            Mapping: "pl7.app/sequence/annotation/mapping",
-        },
-        IsAnnotation: "pl7.app/sequence/isAnnotation",
-    },
-    Table: {
-        FontFamily: "pl7.app/table/fontFamily",
-        OrderPriority: "pl7.app/table/orderPriority",
-        Visibility: "pl7.app/table/visibility",
-    },
-    Trace: "pl7.app/trace",
-    VDJ: {
-        IsAssemblingFeature: "pl7.app/vdj/isAssemblingFeature",
-        IsMainSequence: "pl7.app/vdj/isMainSequence",
-    },
+	AxisNature: "pl7.app/axisNature",
+	Alphabet: "pl7.app/alphabet",
+	Description: "pl7.app/description",
+	DiscreteValues: "pl7.app/discreteValues",
+	Format: "pl7.app/format",
+	Graph: {
+		Axis: {
+			HighCardinality: "pl7.app/graph/axis/highCardinality",
+			LowerLimit: "pl7.app/graph/axis/lowerLimit",
+			SymmetricRange: "pl7.app/graph/axis/symmetricRange",
+			UpperLimit: "pl7.app/graph/axis/upperLimit"
+		},
+		IsDenseAxis: "pl7.app/graph/isDenseAxis",
+		IsVirtual: "pl7.app/graph/isVirtual",
+		Palette: "pl7.app/graph/palette",
+		Thresholds: "pl7.app/graph/thresholds",
+		TreatAbsentValuesAs: "pl7.app/graph/treatAbsentValuesAs"
+	},
+	HideDataFromUi: "pl7.app/hideDataFromUi",
+	HideDataFromGraphs: "pl7.app/hideDataFromGraphs",
+	IsDiscreteFilter: "pl7.app/isDiscreteFilter",
+	IsAnchor: "pl7.app/isAnchor",
+	IsLinkerColumn: "pl7.app/isLinkerColumn",
+	IsScore: "pl7.app/isScore",
+	IsSubset: "pl7.app/isSubset",
+	Label: "pl7.app/label",
+	Max: "pl7.app/max",
+	Min: "pl7.app/min",
+	MultipliesBy: "pl7.app/multipliesBy",
+	Parents: "pl7.app/parents",
+	Score: {
+		DefaultCutoff: "pl7.app/score/defaultCutoff",
+		RankingOrder: "pl7.app/score/rankingOrder"
+	},
+	Sequence: {
+		Annotation: { Mapping: "pl7.app/sequence/annotation/mapping" },
+		IsAnnotation: "pl7.app/sequence/isAnnotation"
+	},
+	Table: {
+		FontFamily: "pl7.app/table/fontFamily",
+		OrderPriority: "pl7.app/table/orderPriority",
+		Visibility: "pl7.app/table/visibility"
+	},
+	Trace: "pl7.app/trace",
+	VDJ: {
+		IsAssemblingFeature: "pl7.app/vdj/isAssemblingFeature",
+		IsMainSequence: "pl7.app/vdj/isMainSequence"
+	}
 };
-const ValueTypeSchema = zod.z.enum(["Int", "Long", "Float", "Double", "String"]);
+const ValueTypeSchema = zod.z.enum([
+	"Int",
+	"Long",
+	"Float",
+	"Double",
+	"String"
+]);
 const AnnotationJson = {
-    [Annotation.DiscreteValues]: zod.z.array(zod.z.string()).or(zod.z.array(zod.z.number())),
-    [Annotation.Graph.Axis.HighCardinality]: zod.z.boolean(),
-    [Annotation.Graph.Axis.LowerLimit]: zod.z.number(),
-    [Annotation.Graph.Axis.UpperLimit]: zod.z.number(),
-    [Annotation.Graph.Axis.SymmetricRange]: zod.z.boolean(),
-    [Annotation.Graph.IsDenseAxis]: zod.z.boolean(),
-    [Annotation.Graph.Palette]: zod.z.object({ mapping: zod.z.record(zod.z.number()), name: zod.z.string() }),
-    [Annotation.Graph.Thresholds]: zod.z.array(zod.z.object({
-        columnId: zod.z.object({ valueType: ValueTypeSchema, name: zod.z.string() }),
-        value: zod.z.number(),
-    })),
-    [Annotation.Graph.TreatAbsentValuesAs]: zod.z.number(),
-    [Annotation.Graph.IsVirtual]: zod.z.boolean(),
-    [Annotation.HideDataFromUi]: zod.z.boolean(),
-    [Annotation.HideDataFromGraphs]: zod.z.boolean(),
-    [Annotation.IsDiscreteFilter]: zod.z.boolean(),
-    [Annotation.IsLinkerColumn]: zod.z.boolean(),
-    [Annotation.IsSubset]: zod.z.boolean(),
-    [Annotation.Max]: zod.z.number(),
-    [Annotation.Min]: zod.z.number(),
-    [Annotation.MultipliesBy]: zod.z.array(zod.z.string()),
-    [Annotation.Parents]: zod.z.array(zod.z.string()),
-    [Annotation.Sequence.Annotation.Mapping]: zod.z.record(zod.z.string(), zod.z.string()),
-    [Annotation.Sequence.IsAnnotation]: zod.z.boolean(),
-    [Annotation.Table.OrderPriority]: zod.z.number(),
-    [Annotation.Trace]: zod.z.record(zod.z.string(), zod.z.unknown()),
-    [Annotation.VDJ.IsAssemblingFeature]: zod.z.boolean(),
+	[Annotation.DiscreteValues]: zod.z.array(zod.z.string()).or(zod.z.array(zod.z.number())),
+	[Annotation.Graph.Axis.HighCardinality]: zod.z.boolean(),
+	[Annotation.Graph.Axis.LowerLimit]: zod.z.number(),
+	[Annotation.Graph.Axis.UpperLimit]: zod.z.number(),
+	[Annotation.Graph.Axis.SymmetricRange]: zod.z.boolean(),
+	[Annotation.Graph.IsDenseAxis]: zod.z.boolean(),
+	[Annotation.Graph.Palette]: zod.z.object({
+		mapping: zod.z.record(zod.z.number()),
+		name: zod.z.string()
+	}),
+	[Annotation.Graph.Thresholds]: zod.z.array(zod.z.object({
+		columnId: zod.z.object({
+			valueType: ValueTypeSchema,
+			name: zod.z.string()
+		}),
+		value: zod.z.number()
+	})),
+	[Annotation.Graph.TreatAbsentValuesAs]: zod.z.number(),
+	[Annotation.Graph.IsVirtual]: zod.z.boolean(),
+	[Annotation.HideDataFromUi]: zod.z.boolean(),
+	[Annotation.HideDataFromGraphs]: zod.z.boolean(),
+	[Annotation.IsDiscreteFilter]: zod.z.boolean(),
+	[Annotation.IsLinkerColumn]: zod.z.boolean(),
+	[Annotation.IsSubset]: zod.z.boolean(),
+	[Annotation.Max]: zod.z.number(),
+	[Annotation.Min]: zod.z.number(),
+	[Annotation.MultipliesBy]: zod.z.array(zod.z.string()),
+	[Annotation.Parents]: zod.z.array(zod.z.string()),
+	[Annotation.Sequence.Annotation.Mapping]: zod.z.record(zod.z.string(), zod.z.string()),
+	[Annotation.Sequence.IsAnnotation]: zod.z.boolean(),
+	[Annotation.Table.OrderPriority]: zod.z.number(),
+	[Annotation.Trace]: zod.z.record(zod.z.string(), zod.z.unknown()),
+	[Annotation.VDJ.IsAssemblingFeature]: zod.z.boolean()
 };
-/// Helper function for reading plain annotation values
 function readAnnotation(spec, key) {
-    return readMetadata(spec?.annotations, key);
+	return readMetadata(spec?.annotations, key);
 }
-/// Helper function for reading json-encoded annotation values, throws on JSON parsing error
 function readAnnotationJsonOrThrow(spec, key) {
-    return readMetadataJsonOrThrow(spec?.annotations, AnnotationJson, key, "readAnnotationJsonOrThrow");
+	return readMetadataJsonOrThrow(spec?.annotations, AnnotationJson, key, "readAnnotationJsonOrThrow");
 }
-/// Helper function for reading json-encoded annotation values, returns undefined on JSON parsing error
 function readAnnotationJson(spec, key) {
-    return readMetadataJson(spec?.annotations, AnnotationJson, key);
+	return readMetadataJson(spec?.annotations, AnnotationJson, key);
 }
 function isLinkerColumn(column) {
-    return !!readAnnotationJson(column, Annotation.IsLinkerColumn);
+	return !!readAnnotationJson(column, Annotation.IsLinkerColumn);
 }
 function makeAxisTree(axis) {
-    return { axis, children: [] };
+	return {
+		axis,
+		children: []
+	};
 }
 /** Build tree by axis parents annotations */
 function getAxesTree(rootAxis) {
-    const root = makeAxisTree(rootAxis);
-    let nodesQ = [root];
-    while (nodesQ.length) {
-        const nextNodes = [];
-        for (const node of nodesQ) {
-            node.children = node.axis.parentAxesSpec.map(makeAxisTree);
-            nextNodes.push(...node.children);
-        }
-        nodesQ = nextNodes;
-    }
-    return root;
+	const root = makeAxisTree(rootAxis);
+	let nodesQ = [root];
+	while (nodesQ.length) {
+		const nextNodes = [];
+		for (const node of nodesQ) {
+			node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+			nextNodes.push(...node.children);
+		}
+		nodesQ = nextNodes;
+	}
+	return root;
 }
 /** Get set of canonicalized axisIds from axisTree */
 function getSetFromAxisTree(tree) {
-    const set = new Set([json.canonicalizeJson(getAxisId(tree.axis))]);
-    let nodesQ = [tree];
-    while (nodesQ.length) {
-        const nextNodes = [];
-        for (const node of nodesQ) {
-            for (const parent of node.children) {
-                set.add(json.canonicalizeJson(getAxisId(parent.axis)));
-                nextNodes.push(parent);
-            }
-        }
-        nodesQ = nextNodes;
-    }
-    return set;
+	const set = new Set([require_json.canonicalizeJson(getAxisId(tree.axis))]);
+	let nodesQ = [tree];
+	while (nodesQ.length) {
+		const nextNodes = [];
+		for (const node of nodesQ) for (const parent of node.children) {
+			set.add(require_json.canonicalizeJson(getAxisId(parent.axis)));
+			nextNodes.push(parent);
+		}
+		nodesQ = nextNodes;
+	}
+	return set;
 }
 /** Get array of axisSpecs from axisTree */
 function getArrayFromAxisTree(tree) {
-    const res = [tree.axis];
-    let nodesQ = [tree];
-    while (nodesQ.length) {
-        const nextNodes = [];
-        for (const node of nodesQ) {
-            for (const parent of node.children) {
-                res.push(parent.axis);
-                nextNodes.push(parent);
-            }
-        }
-        nodesQ = nextNodes;
-    }
-    return res;
+	const res = [tree.axis];
+	let nodesQ = [tree];
+	while (nodesQ.length) {
+		const nextNodes = [];
+		for (const node of nodesQ) for (const parent of node.children) {
+			res.push(parent.axis);
+			nextNodes.push(parent);
+		}
+		nodesQ = nextNodes;
+	}
+	return res;
 }
 function canonicalizeAxisWithParents(axis) {
-    return json.canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+	return require_json.canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
 }
 function normalizingAxesComparator(axis1, axis2) {
-    if (axis1.name !== axis2.name) {
-        return axis1.name < axis2.name ? 1 : -1;
-    }
-    if (axis1.type !== axis2.type) {
-        return axis1.type < axis2.type ? 1 : -1;
-    }
-    const domain1 = json.canonicalizeJson(axis1.domain ?? {});
-    const domain2 = json.canonicalizeJson(axis2.domain ?? {});
-    if (domain1 !== domain2) {
-        return domain1 < domain2 ? 1 : -1;
-    }
-    const parents1 = canonicalizeAxisWithParents(axis1);
-    const parents2 = canonicalizeAxisWithParents(axis2);
-    if (parents1 !== parents2) {
-        return parents1 < parents2 ? 1 : -1;
-    }
-    const annotation1 = json.canonicalizeJson(axis1.annotations ?? {});
-    const annotation2 = json.canonicalizeJson(axis2.annotations ?? {});
-    if (annotation1 !== annotation2) {
-        return annotation1 < annotation2 ? 1 : -1;
-    }
-    return 0;
+	if (axis1.name !== axis2.name) return axis1.name < axis2.name ? 1 : -1;
+	if (axis1.type !== axis2.type) return axis1.type < axis2.type ? 1 : -1;
+	const domain1 = require_json.canonicalizeJson(axis1.domain ?? {});
+	const domain2 = require_json.canonicalizeJson(axis2.domain ?? {});
+	if (domain1 !== domain2) return domain1 < domain2 ? 1 : -1;
+	const parents1 = canonicalizeAxisWithParents(axis1);
+	const parents2 = canonicalizeAxisWithParents(axis2);
+	if (parents1 !== parents2) return parents1 < parents2 ? 1 : -1;
+	const annotation1 = require_json.canonicalizeJson(axis1.annotations ?? {});
+	const annotation2 = require_json.canonicalizeJson(axis2.annotations ?? {});
+	if (annotation1 !== annotation2) return annotation1 < annotation2 ? 1 : -1;
+	return 0;
 }
 function parseParentsFromAnnotations(axis) {
-    const parentsList = readAnnotationJson(axis, Annotation.Parents);
-    if (parentsList === undefined) {
-        return [];
-    }
-    return parentsList;
+	const parentsList = readAnnotationJson(axis, Annotation.Parents);
+	if (parentsList === void 0) return [];
+	return parentsList;
 }
 function sortParentsDeep(axisSpec) {
-    axisSpec.parentAxesSpec.forEach(sortParentsDeep);
-    axisSpec.parentAxesSpec.sort(normalizingAxesComparator);
+	axisSpec.parentAxesSpec.forEach(sortParentsDeep);
+	axisSpec.parentAxesSpec.sort(normalizingAxesComparator);
 }
 function hasCycleOfParents(axisSpec) {
-    const root = makeAxisTree(axisSpec);
-    let nodesQ = [root];
-    const ancestors = new Set(json.canonicalizeJson(getAxisId(axisSpec)));
-    while (nodesQ.length) {
-        const nextNodes = [];
-        const levelIds = new Set();
-        for (const node of nodesQ) {
-            node.children = node.axis.parentAxesSpec.map(makeAxisTree);
-            for (const child of node.children) {
-                const childId = json.canonicalizeJson(getAxisId(child.axis));
-                if (!levelIds.has(childId)) {
-                    nextNodes.push(child);
-                    levelIds.add(childId);
-                    if (ancestors.has(childId)) {
-                        return true;
-                    }
-                    ancestors.add(childId);
-                }
-            }
-        }
-        nodesQ = nextNodes;
-    }
-    return false;
+	let nodesQ = [makeAxisTree(axisSpec)];
+	const ancestors = new Set(require_json.canonicalizeJson(getAxisId(axisSpec)));
+	while (nodesQ.length) {
+		const nextNodes = [];
+		const levelIds = /* @__PURE__ */ new Set();
+		for (const node of nodesQ) {
+			node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+			for (const child of node.children) {
+				const childId = require_json.canonicalizeJson(getAxisId(child.axis));
+				if (!levelIds.has(childId)) {
+					nextNodes.push(child);
+					levelIds.add(childId);
+					if (ancestors.has(childId)) return true;
+					ancestors.add(childId);
+				}
+			}
+		}
+		nodesQ = nextNodes;
+	}
+	return false;
 }
 /** Create list of normalized axisSpec (parents are in array of specs, not indexes) */
 function getNormalizedAxesList(axes) {
-    if (!axes.length) {
-        return [];
-    }
-    const modifiedAxes = axes.map((axis) => {
-        const { parentAxes: _, ...copiedRest } = axis;
-        return { ...copiedRest, annotations: { ...copiedRest.annotations }, parentAxesSpec: [] };
-    });
-    axes.forEach((axis, idx) => {
-        const modifiedAxis = modifiedAxes[idx];
-        if (axis.parentAxes) {
-            // if we have parents by indexes then take from the list
-            modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx) => modifiedAxes[idx]);
-        }
-        else {
-            // else try to parse from annotation name
-            const parents = parseParentsFromAnnotations(axis).map((name) => modifiedAxes.find((axis) => axis.name === name));
-            modifiedAxis.parentAxesSpec = parents.some((p) => p === undefined)
-                ? []
-                : parents;
-            delete modifiedAxis.annotations?.[Annotation.Parents];
-        }
-    });
-    if (modifiedAxes.some(hasCycleOfParents)) {
-        // Axes list is broken
-        modifiedAxes.forEach((axis) => {
-            axis.parentAxesSpec = [];
-        });
-    }
-    else {
-        modifiedAxes.forEach((axis) => {
-            sortParentsDeep(axis);
-        });
-    }
-    return modifiedAxes;
+	if (!axes.length) return [];
+	const modifiedAxes = axes.map((axis) => {
+		const { parentAxes: _, ...copiedRest } = axis;
+		return {
+			...copiedRest,
+			annotations: { ...copiedRest.annotations },
+			parentAxesSpec: []
+		};
+	});
+	axes.forEach((axis, idx) => {
+		const modifiedAxis = modifiedAxes[idx];
+		if (axis.parentAxes) modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx) => modifiedAxes[idx]);
+		else {
+			const parents = parseParentsFromAnnotations(axis).map((name) => modifiedAxes.find((axis) => axis.name === name));
+			modifiedAxis.parentAxesSpec = parents.some((p) => p === void 0) ? [] : parents;
+			delete modifiedAxis.annotations?.[Annotation.Parents];
+		}
+	});
+	if (modifiedAxes.some(hasCycleOfParents)) modifiedAxes.forEach((axis) => {
+		axis.parentAxesSpec = [];
+	});
+	else modifiedAxes.forEach((axis) => {
+		sortParentsDeep(axis);
+	});
+	return modifiedAxes;
 }
 /** Create list of regular axisSpec from normalized (parents are indexes, inside of current axes list) */
 function getDenormalizedAxesList(axesSpec) {
-    const idsList = axesSpec.map((axisSpec) => json.canonicalizeJson(getAxisId(axisSpec)));
-    return axesSpec.map((axisSpec) => {
-        const parentsIds = axisSpec.parentAxesSpec.map((axisSpec) => json.canonicalizeJson(getAxisId(axisSpec)));
-        const parentIdxs = parentsIds.map((id) => idsList.indexOf(id));
-        const { parentAxesSpec: _, ...copiedRest } = axisSpec;
-        if (parentIdxs.length) {
-            return { ...copiedRest, parentAxes: parentIdxs };
-        }
-        return copiedRest;
-    });
+	const idsList = axesSpec.map((axisSpec) => require_json.canonicalizeJson(getAxisId(axisSpec)));
+	return axesSpec.map((axisSpec) => {
+		const parentIdxs = axisSpec.parentAxesSpec.map((axisSpec) => require_json.canonicalizeJson(getAxisId(axisSpec))).map((id) => idsList.indexOf(id));
+		const { parentAxesSpec: _, ...copiedRest } = axisSpec;
+		if (parentIdxs.length) return {
+			...copiedRest,
+			parentAxes: parentIdxs
+		};
+		return copiedRest;
+	});
 }
-/// Well-known column names
 const PColumnName = {
-    Label: "pl7.app/label",
-    Table: {
-        RowSelection: "pl7.app/table/row-selection",
-    },
-    VDJ: {
-        LeadSelection: "pl7.app/vdj/lead-selection",
-        RankingOrder: "pl7.app/vdj/ranking-order",
-        Sequence: "pl7.app/vdj/sequence",
-    },
+	Label: "pl7.app/label",
+	Table: { RowSelection: "pl7.app/table/row-selection" },
+	VDJ: {
+		LeadSelection: "pl7.app/vdj/lead-selection",
+		RankingOrder: "pl7.app/vdj/ranking-order",
+		Sequence: "pl7.app/vdj/sequence"
+	}
 };
-/// Well-known axis names
 const PAxisName = {
-    SampleId: "pl7.app/sampleId",
-    VDJ: {
-        Assay: {
-            SequenceId: "pl7.app/vdj/assay/sequenceId",
-        },
-        ClusterId: "pl7.app/vdj/clusterId",
-        ClonotypeKey: "pl7.app/vdj/clonotypeKey",
-        ScClonotypeKey: "pl7.app/vdj/scClonotypeKey",
-    },
+	SampleId: "pl7.app/sampleId",
+	VDJ: {
+		Assay: { SequenceId: "pl7.app/vdj/assay/sequenceId" },
+		ClusterId: "pl7.app/vdj/clusterId",
+		ClonotypeKey: "pl7.app/vdj/clonotypeKey",
+		ScClonotypeKey: "pl7.app/vdj/scClonotypeKey"
+	}
 };
 function isLabelColumn(column) {
-    return column.axesSpec.length === 1 && column.name === PColumnName.Label;
+	return column.axesSpec.length === 1 && column.name === PColumnName.Label;
 }
 function getPColumnSpecId(spec) {
-    return {
-        kind: spec.kind,
-        valueType: spec.valueType,
-        name: spec.name,
-        domain: spec.domain,
-        parentAxes: spec.parentAxes,
-        axesId: getAxesId(spec.axesSpec),
-    };
+	return {
+		kind: spec.kind,
+		valueType: spec.valueType,
+		name: spec.name,
+		domain: spec.domain,
+		parentAxes: spec.parentAxes,
+		axesId: getAxesId(spec.axesSpec)
+	};
 }
 /** Get column id and spec from a column */
 function getColumnIdAndSpec(column) {
-    return {
-        columnId: column.id,
-        spec: column.spec,
-    };
+	return {
+		columnId: column.id,
+		spec: column.spec
+	};
 }
 /** Extracts axis ids from axis spec */
 function getAxisId(spec) {
-    const { type, name, domain } = spec;
-    const result = { type, name };
-    if (domain && Object.entries(domain).length > 0) {
-        Object.assign(result, { domain });
-    }
-    return result;
+	const { type, name, domain } = spec;
+	const result = {
+		type,
+		name
+	};
+	if (domain && Object.entries(domain).length > 0) Object.assign(result, { domain });
+	return result;
 }
 /** Extracts axes ids from axes spec array from column spec */
 function getAxesId(spec) {
-    return spec.map(getAxisId);
+	return spec.map(getAxisId);
 }
 /** Canonicalizes axis id */
 function canonicalizeAxisId(id) {
-    return json.canonicalizeJson(getAxisId(id));
+	return require_json.canonicalizeJson(getAxisId(id));
 }
 /** Returns true if all domains from query are found in target */
 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;
 }
 /** Returns whether "match" axis id is compatible with the "query" */
 function matchAxisId(query, target) {
-    return query.name === target.name && matchDomain(query.domain, target.domain);
+	return query.name === target.name && matchDomain(query.domain, target.domain);
 }
 function getTypeFromPColumnOrAxisSpec(spec) {
-    return "valueType" in spec ? spec.valueType : spec.type;
+	return "valueType" in spec ? spec.valueType : spec.type;
 }
 function isAxisId(id) {
-    return typeof id === "object" && id !== null && "name" in id && "type" in id;
+	return typeof id === "object" && id !== null && "name" in id && "type" in id;
 }
 
+//#endregion
 exports.Annotation = Annotation;
 exports.AnnotationJson = AnnotationJson;
 exports.Domain = Domain;
@@ -441,4 +399,4 @@ exports.readDomainJsonOrThrow = readDomainJsonOrThrow;
 exports.readMetadata = readMetadata;
 exports.readMetadataJson = readMetadataJson;
 exports.readMetadataJsonOrThrow = readMetadataJsonOrThrow;
-//# sourceMappingURL=spec.cjs.map
+//# sourceMappingURL=spec.cjs.map