@platforma-sdk/model 1.58.3 → 1.58.9

package/dist/render/util/pcolumn_data.js

@@ -1,6 +1,7 @@
-import { isDataInfoEntries, isDataInfo, dataInfoToEntries, visitDataInfo } from '@milaboratories/pl-model-common';
-import { TreeNodeAccessor } from '../accessor.js';
+import { TreeNodeAccessor } from "../accessor.js";
+import { dataInfoToEntries, isDataInfo, isDataInfoEntries, visitDataInfo } from "@milaboratories/pl-model-common";
 
+//#region src/render/util/pcolumn_data.ts
 const PCD_PREFIX = "PColumnData/";
 const RT_RESOURCE_MAP = PCD_PREFIX + "ResourceMap";
 const RT_RESOURCE_MAP_PARTITIONED = PCD_PREFIX + "Partitioned/ResourceMap";
@@ -12,399 +13,339 @@ const RT_JSON_SUPER_PARTITIONED = PCD_SUP_PREFIX + "JsonPartitioned";
 const RT_BINARY_SUPER_PARTITIONED = PCD_SUP_PREFIX + "BinaryPartitioned";
 const RT_PARQUET_SUPER_PARTITIONED = PCD_SUP_PREFIX + "ParquetPartitioned";
 function populateResourceMapData(acc, resourceParser, data, keyPrefix = [], addEntriesWithNoData) {
-    if (acc === undefined)
-        return false;
-    switch (acc.resourceType.name) {
-        case RT_RESOURCE_MAP: {
-            let isComplete = acc.getInputsLocked();
-            for (const keyStr of acc.listInputFields()) {
-                const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
-                const key = [...keyPrefix, ...JSON.parse(keyStr)];
-                const converted = value === undefined ? undefined : resourceParser(value);
-                if (converted === undefined)
-                    isComplete = false;
-                if (converted !== undefined || addEntriesWithNoData)
-                    data.push({ key, value: converted });
-            }
-            return isComplete;
-        }
-        case RT_RESOURCE_MAP_PARTITIONED: {
-            let isComplete = acc.getInputsLocked();
-            for (const keyStr of acc.listInputFields()) {
-                const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
-                if (value === undefined)
-                    isComplete = false;
-                else {
-                    const key = [...keyPrefix, ...JSON.parse(keyStr)];
-                    const populateResult = populateResourceMapData(value, resourceParser, data, key, addEntriesWithNoData);
-                    isComplete = isComplete && populateResult;
-                }
-            }
-            return isComplete;
-        }
-        default:
-            throw new Error(`Unknown resource type: ${acc.resourceType.name}`);
-    }
+	if (acc === void 0) return false;
+	switch (acc.resourceType.name) {
+		case RT_RESOURCE_MAP: {
+			let isComplete = acc.getInputsLocked();
+			for (const keyStr of acc.listInputFields()) {
+				const value = acc.resolve({
+					field: keyStr,
+					assertFieldType: "Input"
+				});
+				const key = [...keyPrefix, ...JSON.parse(keyStr)];
+				const converted = value === void 0 ? void 0 : resourceParser(value);
+				if (converted === void 0) isComplete = false;
+				if (converted !== void 0 || addEntriesWithNoData) data.push({
+					key,
+					value: converted
+				});
+			}
+			return isComplete;
+		}
+		case RT_RESOURCE_MAP_PARTITIONED: {
+			let isComplete = acc.getInputsLocked();
+			for (const keyStr of acc.listInputFields()) {
+				const value = acc.resolve({
+					field: keyStr,
+					assertFieldType: "Input"
+				});
+				if (value === void 0) isComplete = false;
+				else {
+					const populateResult = populateResourceMapData(value, resourceParser, data, [...keyPrefix, ...JSON.parse(keyStr)], addEntriesWithNoData);
+					isComplete = isComplete && populateResult;
+				}
+			}
+			return isComplete;
+		}
+		default: throw new Error(`Unknown resource type: ${acc.resourceType.name}`);
+	}
 }
 function parseResourceMap(acc, resourceParser, addEntriesWithNoData = false) {
-    const data = [];
-    const isComplete = populateResourceMapData(acc, resourceParser, data, [], addEntriesWithNoData);
-    return { isComplete, data };
+	const data = [];
+	return {
+		isComplete: populateResourceMapData(acc, resourceParser, data, [], addEntriesWithNoData),
+		data
+	};
 }
 const removeIndexSuffix = (keyStr) => {
-    if (keyStr.endsWith(".index")) {
-        return { baseKey: keyStr.substring(0, keyStr.length - 6), type: "index" };
-    }
-    else if (keyStr.endsWith(".values")) {
-        return { baseKey: keyStr.substring(0, keyStr.length - 7), type: "values" };
-    }
-    else {
-        throw new Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
-    }
+	if (keyStr.endsWith(".index")) return {
+		baseKey: keyStr.substring(0, keyStr.length - 6),
+		type: "index"
+	};
+	else if (keyStr.endsWith(".values")) return {
+		baseKey: keyStr.substring(0, keyStr.length - 7),
+		type: "values"
+	};
+	else throw new Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
 };
-// @TODO define a class with various resource map operations
 /** Returns a list of all partition keys appeared in the p-column */
 function getPartitionKeysList(acc) {
-    if (!acc)
-        return undefined;
-    const rt = acc.resourceType.name;
-    const meta = acc.getDataAsJson();
-    const data = [];
-    let keyLength = 0;
-    // @TODO validate meta shape
-    switch (rt) {
-        case RT_RESOURCE_MAP:
-            keyLength = meta["keyLength"];
-            break;
-        case RT_RESOURCE_MAP_PARTITIONED:
-            keyLength = meta["partitionKeyLength"] + meta["keyLength"];
-            break;
-        case RT_JSON_PARTITIONED:
-        case RT_BINARY_PARTITIONED:
-        case RT_PARQUET_PARTITIONED:
-            keyLength = meta["partitionKeyLength"];
-            break;
-        case RT_BINARY_SUPER_PARTITIONED:
-        case RT_JSON_SUPER_PARTITIONED:
-        case RT_PARQUET_SUPER_PARTITIONED:
-            keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
-            break;
-    }
-    switch (rt) {
-        case RT_RESOURCE_MAP:
-        case RT_JSON_PARTITIONED:
-        case RT_BINARY_PARTITIONED:
-        case RT_PARQUET_PARTITIONED:
-            for (let keyStr of acc.listInputFields()) {
-                if (rt === RT_BINARY_PARTITIONED) {
-                    keyStr = removeIndexSuffix(keyStr).baseKey;
-                }
-                const key = [...JSON.parse(keyStr)];
-                data.push(key);
-            }
-            break;
-        case RT_RESOURCE_MAP_PARTITIONED:
-        case RT_BINARY_SUPER_PARTITIONED:
-        case RT_JSON_SUPER_PARTITIONED:
-        case RT_PARQUET_SUPER_PARTITIONED:
-            for (const supKeyStr of acc.listInputFields()) {
-                const keyPrefix = [...JSON.parse(supKeyStr)];
-                const value = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
-                if (value !== undefined) {
-                    for (let keyStr of value.listInputFields()) {
-                        if (rt === RT_BINARY_SUPER_PARTITIONED) {
-                            keyStr = removeIndexSuffix(keyStr).baseKey;
-                        }
-                        const key = [...keyPrefix, ...JSON.parse(keyStr)];
-                        data.push(key);
-                    }
-                }
-            }
-            break;
-    }
-    return { data, keyLength };
+	if (!acc) return void 0;
+	const rt = acc.resourceType.name;
+	const meta = acc.getDataAsJson();
+	const data = [];
+	let keyLength = 0;
+	switch (rt) {
+		case RT_RESOURCE_MAP:
+			keyLength = meta["keyLength"];
+			break;
+		case RT_RESOURCE_MAP_PARTITIONED:
+			keyLength = meta["partitionKeyLength"] + meta["keyLength"];
+			break;
+		case RT_JSON_PARTITIONED:
+		case RT_BINARY_PARTITIONED:
+		case RT_PARQUET_PARTITIONED:
+			keyLength = meta["partitionKeyLength"];
+			break;
+		case RT_BINARY_SUPER_PARTITIONED:
+		case RT_JSON_SUPER_PARTITIONED:
+		case RT_PARQUET_SUPER_PARTITIONED:
+			keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
+			break;
+	}
+	switch (rt) {
+		case RT_RESOURCE_MAP:
+		case RT_JSON_PARTITIONED:
+		case RT_BINARY_PARTITIONED:
+		case RT_PARQUET_PARTITIONED:
+			for (let keyStr of acc.listInputFields()) {
+				if (rt === RT_BINARY_PARTITIONED) keyStr = removeIndexSuffix(keyStr).baseKey;
+				const key = [...JSON.parse(keyStr)];
+				data.push(key);
+			}
+			break;
+		case RT_RESOURCE_MAP_PARTITIONED:
+		case RT_BINARY_SUPER_PARTITIONED:
+		case RT_JSON_SUPER_PARTITIONED:
+		case RT_PARQUET_SUPER_PARTITIONED:
+			for (const supKeyStr of acc.listInputFields()) {
+				const keyPrefix = [...JSON.parse(supKeyStr)];
+				const value = acc.resolve({
+					field: supKeyStr,
+					assertFieldType: "Input"
+				});
+				if (value !== void 0) for (let keyStr of value.listInputFields()) {
+					if (rt === RT_BINARY_SUPER_PARTITIONED) keyStr = removeIndexSuffix(keyStr).baseKey;
+					const key = [...keyPrefix, ...JSON.parse(keyStr)];
+					data.push(key);
+				}
+			}
+			break;
+	}
+	return {
+		data,
+		keyLength
+	};
 }
 function getUniquePartitionKeysForDataEntries(list) {
-    if (list.type !== "JsonPartitioned" &&
-        list.type !== "BinaryPartitioned" &&
-        list.type !== "ParquetPartitioned")
-        throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${list.type}`);
-    const { parts, partitionKeyLength } = list;
-    const result = [];
-    for (let i = 0; i < partitionKeyLength; ++i) {
-        result.push(new Set());
-    }
-    for (const part of parts) {
-        const key = part.key;
-        if (key.length !== partitionKeyLength) {
-            throw new Error(`Key length (${key.length}) does not match partition length (${partitionKeyLength}) for key: ${JSON.stringify(key)}`);
-        }
-        for (let i = 0; i < partitionKeyLength; ++i) {
-            result[i].add(key[i]);
-        }
-    }
-    return result.map((s) => Array.from(s.values()));
+	if (list.type !== "JsonPartitioned" && list.type !== "BinaryPartitioned" && list.type !== "ParquetPartitioned") throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${list.type}`);
+	const { parts, partitionKeyLength } = list;
+	const result = [];
+	for (let i = 0; i < partitionKeyLength; ++i) result.push(/* @__PURE__ */ new Set());
+	for (const part of parts) {
+		const key = part.key;
+		if (key.length !== partitionKeyLength) throw new Error(`Key length (${key.length}) does not match partition length (${partitionKeyLength}) for key: ${JSON.stringify(key)}`);
+		for (let i = 0; i < partitionKeyLength; ++i) result[i].add(key[i]);
+	}
+	return result.map((s) => Array.from(s.values()));
 }
 function getUniquePartitionKeys(acc) {
-    if (acc === undefined)
-        return undefined;
-    if (isDataInfoEntries(acc))
-        return getUniquePartitionKeysForDataEntries(acc);
-    const list = getPartitionKeysList(acc);
-    if (!list)
-        return undefined;
-    const { data, keyLength } = list;
-    const result = [];
-    for (let i = 0; i < keyLength; ++i) {
-        result.push(new Set());
-    }
-    for (const l of data) {
-        if (l.length !== keyLength) {
-            throw new Error("key length does not match partition length");
-        }
-        for (let i = 0; i < keyLength; ++i) {
-            result[i].add(l[i]);
-        }
-    }
-    return result.map((s) => Array.from(s.values()));
+	if (acc === void 0) return void 0;
+	if (isDataInfoEntries(acc)) return getUniquePartitionKeysForDataEntries(acc);
+	const list = getPartitionKeysList(acc);
+	if (!list) return void 0;
+	const { data, keyLength } = list;
+	const result = [];
+	for (let i = 0; i < keyLength; ++i) result.push(/* @__PURE__ */ new Set());
+	for (const l of data) {
+		if (l.length !== keyLength) throw new Error("key length does not match partition length");
+		for (let i = 0; i < keyLength; ++i) result[i].add(l[i]);
+	}
+	return result.map((s) => Array.from(s.values()));
 }
 /**
- * Parses the PColumn data from a TreeNodeAccessor into a DataInfoEntries structure.
- * Returns undefined if any required data is missing.
- * Throws error on validation failures.
- *
- * @param acc - The TreeNodeAccessor containing PColumn data
- * @param keyPrefix - Optional key prefix for recursive calls
- * @returns DataInfoEntries representation of the PColumn data, or undefined if incomplete
- */
+* Parses the PColumn data from a TreeNodeAccessor into a DataInfoEntries structure.
+* Returns undefined if any required data is missing.
+* Throws error on validation failures.
+*
+* @param acc - The TreeNodeAccessor containing PColumn data
+* @param keyPrefix - Optional key prefix for recursive calls
+* @returns DataInfoEntries representation of the PColumn data, or undefined if incomplete
+*/
 function parsePColumnData(acc, keyPrefix = []) {
-    if (acc === undefined)
-        return undefined;
-    if (!acc.getIsReadyOrError())
-        return undefined;
-    const resourceType = acc.resourceType.name;
-    const meta = acc.getDataAsJson();
-    // Prevent recursive super-partitioned resources
-    if (keyPrefix.length > 0 &&
-        (resourceType === RT_JSON_SUPER_PARTITIONED ||
-            resourceType === RT_BINARY_SUPER_PARTITIONED ||
-            resourceType === RT_PARQUET_SUPER_PARTITIONED)) {
-        throw new Error(`Unexpected nested super-partitioned resource: ${resourceType}`);
-    }
-    switch (resourceType) {
-        case RT_RESOURCE_MAP:
-        case RT_RESOURCE_MAP_PARTITIONED:
-            throw new Error(`Only data columns are supported, got: ${resourceType}`);
-        case RT_JSON_PARTITIONED: {
-            if (typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const parts = [];
-            for (const keyStr of acc.listInputFields()) {
-                const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
-                if (value === undefined)
-                    return undefined;
-                const key = [...keyPrefix, ...JSON.parse(keyStr)];
-                parts.push({ key, value });
-            }
-            return {
-                type: "JsonPartitioned",
-                partitionKeyLength: meta.partitionKeyLength,
-                parts,
-            };
-        }
-        case RT_BINARY_PARTITIONED: {
-            if (typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const parts = [];
-            const baseKeys = new Map();
-            // Group fields by base key (without .index/.values suffix)
-            for (const keyStr of acc.listInputFields()) {
-                const suffix = removeIndexSuffix(keyStr);
-                const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
-                if (value === undefined)
-                    return undefined;
-                let entry = baseKeys.get(suffix.baseKey);
-                if (!entry) {
-                    entry = {};
-                    baseKeys.set(suffix.baseKey, entry);
-                }
-                if (suffix.type === "index") {
-                    entry.index = value;
-                }
-                else {
-                    entry.values = value;
-                }
-            }
-            // Process complete binary chunks only
-            for (const [baseKeyStr, entry] of baseKeys.entries()) {
-                if (!entry.index || !entry.values)
-                    return undefined;
-                const key = [...keyPrefix, ...JSON.parse(baseKeyStr)];
-                parts.push({
-                    key,
-                    value: {
-                        index: entry.index,
-                        values: entry.values,
-                    },
-                });
-            }
-            return {
-                type: "BinaryPartitioned",
-                partitionKeyLength: meta.partitionKeyLength,
-                parts,
-            };
-        }
-        case RT_PARQUET_PARTITIONED: {
-            if (typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const parts = [];
-            for (const keyStr of acc.listInputFields()) {
-                const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
-                if (value === undefined)
-                    return undefined;
-                const key = [...keyPrefix, ...JSON.parse(keyStr)];
-                parts.push({ key, value });
-            }
-            return {
-                type: "ParquetPartitioned",
-                partitionKeyLength: meta.partitionKeyLength,
-                parts,
-            };
-        }
-        case RT_JSON_SUPER_PARTITIONED: {
-            if (typeof meta?.superPartitionKeyLength !== "number" ||
-                typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
-            const parts = [];
-            // Process all super partitions
-            for (const supKeyStr of acc.listInputFields()) {
-                const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
-                if (superPartition === undefined)
-                    return undefined;
-                // Validate inner type
-                if (superPartition.resourceType.name !== RT_JSON_PARTITIONED) {
-                    throw new Error(`Expected ${RT_JSON_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
-                }
-                const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
-                if (innerResult === undefined)
-                    return undefined;
-                if (innerResult.type !== "JsonPartitioned")
-                    throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
-                parts.push(...innerResult.parts);
-            }
-            return {
-                type: "JsonPartitioned",
-                partitionKeyLength: totalKeyLength,
-                parts,
-            };
-        }
-        case RT_BINARY_SUPER_PARTITIONED: {
-            if (typeof meta?.superPartitionKeyLength !== "number" ||
-                typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
-            const parts = [];
-            // Process all super partitions
-            for (const supKeyStr of acc.listInputFields()) {
-                const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
-                if (superPartition === undefined)
-                    return undefined;
-                // Validate inner type
-                if (superPartition.resourceType.name !== RT_BINARY_PARTITIONED) {
-                    throw new Error(`Expected ${RT_BINARY_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
-                }
-                const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
-                if (innerResult === undefined)
-                    return undefined;
-                if (innerResult.type !== "BinaryPartitioned")
-                    throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
-                parts.push(...innerResult.parts);
-            }
-            return {
-                type: "BinaryPartitioned",
-                partitionKeyLength: totalKeyLength,
-                parts,
-            };
-        }
-        case RT_PARQUET_SUPER_PARTITIONED: {
-            if (typeof meta?.superPartitionKeyLength !== "number" ||
-                typeof meta?.partitionKeyLength !== "number") {
-                throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
-            }
-            const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
-            const parts = [];
-            // Process all super partitions
-            for (const supKeyStr of acc.listInputFields()) {
-                const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
-                if (superPartition === undefined)
-                    return undefined;
-                // Validate inner type
-                if (superPartition.resourceType.name !== RT_PARQUET_PARTITIONED) {
-                    throw new Error(`Expected ${RT_PARQUET_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
-                }
-                const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
-                if (innerResult === undefined)
-                    return undefined;
-                if (innerResult.type !== "ParquetPartitioned")
-                    throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
-                parts.push(...innerResult.parts);
-            }
-            return {
-                type: "ParquetPartitioned",
-                partitionKeyLength: totalKeyLength,
-                parts,
-            };
-        }
-        default:
-            throw new Error(`Unknown resource type: ${resourceType}`);
-    }
+	if (acc === void 0) return void 0;
+	if (!acc.getIsReadyOrError()) return void 0;
+	const resourceType = acc.resourceType.name;
+	const meta = acc.getDataAsJson();
+	if (keyPrefix.length > 0 && (resourceType === RT_JSON_SUPER_PARTITIONED || resourceType === RT_BINARY_SUPER_PARTITIONED || resourceType === RT_PARQUET_SUPER_PARTITIONED)) throw new Error(`Unexpected nested super-partitioned resource: ${resourceType}`);
+	switch (resourceType) {
+		case RT_RESOURCE_MAP:
+		case RT_RESOURCE_MAP_PARTITIONED: throw new Error(`Only data columns are supported, got: ${resourceType}`);
+		case RT_JSON_PARTITIONED: {
+			if (typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
+			const parts = [];
+			for (const keyStr of acc.listInputFields()) {
+				const value = acc.resolve({
+					field: keyStr,
+					assertFieldType: "Input"
+				});
+				if (value === void 0) return void 0;
+				const key = [...keyPrefix, ...JSON.parse(keyStr)];
+				parts.push({
+					key,
+					value
+				});
+			}
+			return {
+				type: "JsonPartitioned",
+				partitionKeyLength: meta.partitionKeyLength,
+				parts
+			};
+		}
+		case RT_BINARY_PARTITIONED: {
+			if (typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
+			const parts = [];
+			const baseKeys = /* @__PURE__ */ new Map();
+			for (const keyStr of acc.listInputFields()) {
+				const suffix = removeIndexSuffix(keyStr);
+				const value = acc.resolve({
+					field: keyStr,
+					assertFieldType: "Input"
+				});
+				if (value === void 0) return void 0;
+				let entry = baseKeys.get(suffix.baseKey);
+				if (!entry) {
+					entry = {};
+					baseKeys.set(suffix.baseKey, entry);
+				}
+				if (suffix.type === "index") entry.index = value;
+				else entry.values = value;
+			}
+			for (const [baseKeyStr, entry] of baseKeys.entries()) {
+				if (!entry.index || !entry.values) return void 0;
+				const key = [...keyPrefix, ...JSON.parse(baseKeyStr)];
+				parts.push({
+					key,
+					value: {
+						index: entry.index,
+						values: entry.values
+					}
+				});
+			}
+			return {
+				type: "BinaryPartitioned",
+				partitionKeyLength: meta.partitionKeyLength,
+				parts
+			};
+		}
+		case RT_PARQUET_PARTITIONED: {
+			if (typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
+			const parts = [];
+			for (const keyStr of acc.listInputFields()) {
+				const value = acc.resolve({
+					field: keyStr,
+					assertFieldType: "Input"
+				});
+				if (value === void 0) return void 0;
+				const key = [...keyPrefix, ...JSON.parse(keyStr)];
+				parts.push({
+					key,
+					value
+				});
+			}
+			return {
+				type: "ParquetPartitioned",
+				partitionKeyLength: meta.partitionKeyLength,
+				parts
+			};
+		}
+		case RT_JSON_SUPER_PARTITIONED: {
+			if (typeof meta?.superPartitionKeyLength !== "number" || typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+			const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+			const parts = [];
+			for (const supKeyStr of acc.listInputFields()) {
+				const superPartition = acc.resolve({
+					field: supKeyStr,
+					assertFieldType: "Input"
+				});
+				if (superPartition === void 0) return void 0;
+				if (superPartition.resourceType.name !== RT_JSON_PARTITIONED) throw new Error(`Expected ${RT_JSON_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+				const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
+				if (innerResult === void 0) return void 0;
+				if (innerResult.type !== "JsonPartitioned") throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+				parts.push(...innerResult.parts);
+			}
+			return {
+				type: "JsonPartitioned",
+				partitionKeyLength: totalKeyLength,
+				parts
+			};
+		}
+		case RT_BINARY_SUPER_PARTITIONED: {
+			if (typeof meta?.superPartitionKeyLength !== "number" || typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+			const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+			const parts = [];
+			for (const supKeyStr of acc.listInputFields()) {
+				const superPartition = acc.resolve({
+					field: supKeyStr,
+					assertFieldType: "Input"
+				});
+				if (superPartition === void 0) return void 0;
+				if (superPartition.resourceType.name !== RT_BINARY_PARTITIONED) throw new Error(`Expected ${RT_BINARY_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+				const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
+				if (innerResult === void 0) return void 0;
+				if (innerResult.type !== "BinaryPartitioned") throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+				parts.push(...innerResult.parts);
+			}
+			return {
+				type: "BinaryPartitioned",
+				partitionKeyLength: totalKeyLength,
+				parts
+			};
+		}
+		case RT_PARQUET_SUPER_PARTITIONED: {
+			if (typeof meta?.superPartitionKeyLength !== "number" || typeof meta?.partitionKeyLength !== "number") throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+			const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+			const parts = [];
+			for (const supKeyStr of acc.listInputFields()) {
+				const superPartition = acc.resolve({
+					field: supKeyStr,
+					assertFieldType: "Input"
+				});
+				if (superPartition === void 0) return void 0;
+				if (superPartition.resourceType.name !== RT_PARQUET_PARTITIONED) throw new Error(`Expected ${RT_PARQUET_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+				const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
+				if (innerResult === void 0) return void 0;
+				if (innerResult.type !== "ParquetPartitioned") throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+				parts.push(...innerResult.parts);
+			}
+			return {
+				type: "ParquetPartitioned",
+				partitionKeyLength: totalKeyLength,
+				parts
+			};
+		}
+		default: throw new Error(`Unknown resource type: ${resourceType}`);
+	}
 }
 /**
- * Converts or parses the input into DataInfoEntries format.
+* Converts or parses the input into DataInfoEntries format.
 
- * @param acc - The input data, which can be TreeNodeAccessor, DataInfoEntries, DataInfo, or undefined.
- * @returns The data in DataInfoEntries format, or undefined if the input was undefined or data is not ready.
- */
+* @param acc - The input data, which can be TreeNodeAccessor, DataInfoEntries, DataInfo, or undefined.
+* @returns The data in DataInfoEntries format, or undefined if the input was undefined or data is not ready.
+*/
 function convertOrParsePColumnData(acc) {
-    if (acc === undefined)
-        return undefined;
-    if (isDataInfoEntries(acc))
-        return acc;
-    if (isDataInfo(acc))
-        return dataInfoToEntries(acc);
-    if (acc instanceof TreeNodeAccessor)
-        return parsePColumnData(acc);
-    throw new Error(`Unexpected input type: ${typeof acc}`);
+	if (acc === void 0) return void 0;
+	if (isDataInfoEntries(acc)) return acc;
+	if (isDataInfo(acc)) return dataInfoToEntries(acc);
+	if (acc instanceof TreeNodeAccessor) return parsePColumnData(acc);
+	throw new Error(`Unexpected input type: ${typeof acc}`);
 }
 function isPColumnReady(c) {
-    const isValues = (d) => Array.isArray(d);
-    const isAccessor = (d) => d instanceof TreeNodeAccessor;
-    let ready = true;
-    const data = typeof c.data === "function" ? c.data() : c.data;
-    if (data == null) {
-        return false;
-    }
-    else if (isAccessor(data)) {
-        ready &&= data.getIsReadyOrError();
-    }
-    else if (isDataInfo(data)) {
-        visitDataInfo(data, (v) => (ready &&= v.getIsReadyOrError()));
-    }
-    else if (!isValues(data)) {
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        throw Error(`unsupported column data type: ${data}`);
-    }
-    return ready;
+	const isValues = (d) => Array.isArray(d);
+	const isAccessor = (d) => d instanceof TreeNodeAccessor;
+	let ready = true;
+	const data = typeof c.data === "function" ? c.data() : c.data;
+	if (data == null) return false;
+	else if (isAccessor(data)) ready &&= data.getIsReadyOrError();
+	else if (isDataInfo(data)) visitDataInfo(data, (v) => ready &&= v.getIsReadyOrError());
+	else if (!isValues(data)) throw Error(`unsupported column data type: ${data}`);
+	return ready;
 }
 function allPColumnsReady(columns) {
-    return columns.every(isPColumnReady);
+	return columns.every(isPColumnReady);
 }
 
+//#endregion
 export { RT_BINARY_PARTITIONED, RT_BINARY_SUPER_PARTITIONED, RT_JSON_PARTITIONED, RT_JSON_SUPER_PARTITIONED, RT_PARQUET_PARTITIONED, RT_PARQUET_SUPER_PARTITIONED, RT_RESOURCE_MAP, RT_RESOURCE_MAP_PARTITIONED, allPColumnsReady, convertOrParsePColumnData, getPartitionKeysList, getUniquePartitionKeys, isPColumnReady, parsePColumnData, parseResourceMap };
-//# sourceMappingURL=pcolumn_data.js.map
+//# sourceMappingURL=pcolumn_data.js.map