@milaboratories/pl-model-common 1.19.6 → 1.19.8

package/dist/drivers/pframe/data_info.js

@@ -0,0 +1,266 @@
+import { assertNever } from '../../util.js';
+
+/**
+ * Type guard function that checks if the given value is a valid DataInfo.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid DataInfo, false otherwise
+ */
+function isDataInfo(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const data = value;
+    if (!('type' in data)) {
+        return false;
+    }
+    switch (data.type) {
+        case 'Json':
+            return (typeof data.keyLength === 'number'
+                && data.data !== undefined
+                && typeof data.data === 'object');
+        case 'JsonPartitioned':
+        case 'BinaryPartitioned':
+        case 'ParquetPartitioned':
+            return (typeof data.partitionKeyLength === 'number'
+                && data.parts !== undefined
+                && typeof data.parts === 'object');
+        default:
+            return false;
+    }
+}
+function mapDataInfo(dataInfo, mapFn) {
+    if (dataInfo === undefined) {
+        return undefined;
+    }
+    switch (dataInfo.type) {
+        case 'Json':
+            // Json type doesn't contain blobs, so return as is
+            return dataInfo;
+        case 'JsonPartitioned': {
+            // Map each blob in parts
+            const newParts = {};
+            for (const [key, blob] of Object.entries(dataInfo.parts)) {
+                newParts[key] = mapFn(blob);
+            }
+            return {
+                ...dataInfo,
+                parts: newParts,
+            };
+        }
+        case 'BinaryPartitioned': {
+            // Map each index and values blob in parts
+            const newParts = {};
+            for (const [key, chunk] of Object.entries(dataInfo.parts)) {
+                newParts[key] = {
+                    index: mapFn(chunk.index),
+                    values: mapFn(chunk.values),
+                };
+            }
+            return {
+                ...dataInfo,
+                parts: newParts,
+            };
+        }
+        case 'ParquetPartitioned': {
+            // Map each blob in parts
+            const newParts = {};
+            for (const [key, blob] of Object.entries(dataInfo.parts)) {
+                newParts[key] = mapFn(blob);
+            }
+            return {
+                ...dataInfo,
+                parts: newParts,
+            };
+        }
+    }
+}
+/**
+ * @param dataInfo - The source DataInfo object
+ * @param cb - Callback, function that have access to every blob to visit them all
+ * @returns Nothing
+ */
+function visitDataInfo(dataInfo, cb) {
+    switch (dataInfo.type) {
+        case 'Json':
+            // Json type doesn't contain blobs, so return as is
+            break;
+        case 'JsonPartitioned': {
+            // Visit each blob in parts
+            Object.values(dataInfo.parts).forEach(cb);
+            break;
+        }
+        case 'BinaryPartitioned': {
+            // Visit each index and values blob in parts
+            Object.values(dataInfo.parts).forEach((chunk) => {
+                cb(chunk.index);
+                cb(chunk.values);
+            });
+            break;
+        }
+        case 'ParquetPartitioned': {
+            // Visit each blob in parts
+            Object.values(dataInfo.parts).forEach(cb);
+            break;
+        }
+    }
+}
+/**
+ * Type guard function that checks if the given value is a valid DataInfoEntries.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid DataInfoEntries, false otherwise
+ */
+function isDataInfoEntries(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const data = value;
+    if (!('type' in data)) {
+        return false;
+    }
+    switch (data.type) {
+        case 'Json':
+            return (typeof data.keyLength === 'number'
+                && Array.isArray(data.data));
+        case 'JsonPartitioned':
+        case 'BinaryPartitioned':
+        case 'ParquetPartitioned':
+            return (typeof data.partitionKeyLength === 'number'
+                && Array.isArray(data.parts));
+        default:
+            return false;
+    }
+}
+/**
+ * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.
+ *
+ * @template Blob - Type parameter representing the storage reference type
+ * @param value - The value to check
+ * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise
+ */
+function isPartitionedDataInfoEntries(value) {
+    if (!isDataInfoEntries(value))
+        return false;
+    switch (value.type) {
+        case 'JsonPartitioned':
+        case 'BinaryPartitioned':
+        case 'ParquetPartitioned':
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Converts DataInfo to DataInfoEntries
+ *
+ * @param dataInfo - The record-based DataInfo object
+ * @returns The equivalent entry-based DataInfoEntries object
+ */
+function dataInfoToEntries(dataInfo) {
+    switch (dataInfo.type) {
+        case 'Json': return {
+            type: 'Json',
+            keyLength: dataInfo.keyLength,
+            data: Object.entries(dataInfo.data).map(([keyStr, value]) => {
+                const key = JSON.parse(keyStr);
+                return { key, value };
+            }),
+        };
+        case 'JsonPartitioned': return {
+            type: 'JsonPartitioned',
+            partitionKeyLength: dataInfo.partitionKeyLength,
+            parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+                const key = JSON.parse(keyStr);
+                return { key, value: blob };
+            }),
+        };
+        case 'BinaryPartitioned': return {
+            type: 'BinaryPartitioned',
+            partitionKeyLength: dataInfo.partitionKeyLength,
+            parts: Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {
+                const key = JSON.parse(keyStr);
+                return { key, value: chunk };
+            }),
+        };
+        case 'ParquetPartitioned': return {
+            type: 'ParquetPartitioned',
+            partitionKeyLength: dataInfo.partitionKeyLength,
+            parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+                const key = JSON.parse(keyStr);
+                return { key, value: blob };
+            }),
+        };
+        default:
+            assertNever(dataInfo);
+    }
+}
+/**
+ * Converts DataInfoEntries to DataInfo
+ *
+ * @param dataInfoEntries - The entry-based DataInfoEntries object
+ * @returns The equivalent record-based DataInfo object
+ */
+function entriesToDataInfo(dataInfoEntries) {
+    switch (dataInfoEntries.type) {
+        case 'Json': return {
+            type: 'Json',
+            keyLength: dataInfoEntries.keyLength,
+            data: Object.fromEntries(dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value])),
+        };
+        case 'JsonPartitioned': return {
+            type: 'JsonPartitioned',
+            partitionKeyLength: dataInfoEntries.partitionKeyLength,
+            parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+        };
+        case 'BinaryPartitioned': return {
+            type: 'BinaryPartitioned',
+            partitionKeyLength: dataInfoEntries.partitionKeyLength,
+            parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+        };
+        case 'ParquetPartitioned': return {
+            type: 'ParquetPartitioned',
+            partitionKeyLength: dataInfoEntries.partitionKeyLength,
+            parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+        };
+        default:
+            assertNever(dataInfoEntries);
+    }
+}
+function mapDataInfoEntries(dataInfoEntries, mapFn) {
+    if (dataInfoEntries === undefined) {
+        return undefined;
+    }
+    switch (dataInfoEntries.type) {
+        case 'Json':
+            // Json type doesn't contain blobs, so return as is
+            return dataInfoEntries;
+        case 'JsonPartitioned': return {
+            ...dataInfoEntries,
+            parts: dataInfoEntries.parts.map((entry) => ({
+                key: entry.key,
+                value: mapFn(entry.value),
+            })),
+        };
+        case 'BinaryPartitioned': return {
+            ...dataInfoEntries,
+            parts: dataInfoEntries.parts.map((entry) => ({
+                key: entry.key,
+                value: {
+                    index: mapFn(entry.value.index),
+                    values: mapFn(entry.value.values),
+                },
+            })),
+        };
+        case 'ParquetPartitioned': return {
+            ...dataInfoEntries,
+            parts: dataInfoEntries.parts.map((entry) => ({
+                key: entry.key,
+                value: mapFn(entry.value),
+            })),
+        };
+    }
+}
+
+export { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo };
+//# sourceMappingURL=data_info.js.map

package/dist/drivers/pframe/data_info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_info.js","sources":["../../../src/drivers/pframe/data_info.ts"],"sourcesContent":["import { assertNever } from '../../util';\n\n/**\n * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.\n * These are the primitive types that can be stored directly in PColumns.\n *\n * Note: Actual columns can hold more value types, which are converted to these JavaScript types\n * once they enter the JavaScript runtime.\n */\nexport type PColumnValue = null | number | string;\n\n/**\n * Represents a key for a PColumn value.\n * Can be an array of strings or numbers.\n */\nexport type PColumnKey = (number | string)[];\n\n/**\n * Represents a single entry in a PColumn's data structure.\n * Contains a key and a value.\n */\nexport type PColumnDataEntry<T> = {\n  /** Key for the value */\n  key: PColumnKey;\n\n  /** Value / blob at the given key */\n  value: T;\n};\n\n/**\n * Represents column data stored as a simple JSON structure.\n * Used for small datasets that can be efficiently stored directly in memory.\n */\nexport type JsonDataInfo = {\n  /** Identifier for this data format ('Json') */\n  type: 'Json';\n\n  /** Number of axes that make up the complete key (tuple length) */\n  keyLength: number;\n\n  /**\n   * Key-value pairs where keys are stringified tuples of axis values\n   * and values are the column values for those coordinates\n   */\n  data: Record<string, PColumnValue>;\n};\n\n/**\n * Represents column data partitioned across multiple JSON blobs.\n * Used for larger datasets that need to be split into manageable chunks.\n */\nexport type JsonPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('JsonPartitioned') */\n  type: 'JsonPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to blob references */\n  parts: Record<string, Blob>;\n};\n\n/**\n * Represents a binary format chunk containing index and values as separate blobs.\n * Used for efficient storage and retrieval of column data in binary format.\n */\nexport type BinaryChunk<Blob> = {\n  /** Binary blob containing structured index information */\n  index: Blob;\n\n  /** Binary blob containing the actual values */\n  values: Blob;\n};\n\n/**\n * Represents column data partitioned across multiple binary chunks.\n * Optimized for efficient storage and retrieval of large datasets.\n */\nexport type BinaryPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('BinaryPartitioned') */\n  type: 'BinaryPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to binary chunks */\n  parts: Record<string, BinaryChunk<Blob>>;\n};\n\nexport type ParquetChunkMappingAxis = {\n  /** Data type (matches PColumn axis types) */\n  type: 'Int' | 'Long' | 'String';\n\n  /** Field name in the Parquet file */\n  id: string;\n};\n\nexport type ParquetChunkMappingColumn = {\n  /** Data type (matches PColumn value type) */\n  type: 'Int' | 'Long' | 'Float' | 'Double' | 'String';\n\n  /** Field name in the Parquet file */\n  id: string;\n};\n\nexport type ParquetChunkMapping = {\n  /** Axes mappings - Parquet file is sorted by these fields in this order */\n  axes: ParquetChunkMappingAxis[];\n\n  /** Column mapping */\n  column: ParquetChunkMappingColumn;\n};\n\nexport type ParquetChunkStats = {\n  /** Number of rows in the chunk */\n  numberOfRows: number;\n  /** Byte size information for storage optimization and query planning */\n  size: {\n    /** Byte sizes for each axis column in the same order as axes mapping */\n    axes: number[];\n    /** Byte size for the data column */\n    column: number;\n  };\n};\n\nexport type ParquetChunkMetadata = {\n  /** Content hash calculated for the specific axes and data this chunk represents */\n  dataDigest: string;\n\n  /** Pre-computed statistics for optimization without blob download */\n  stats: Partial<ParquetChunkStats>;\n};\n\nexport type ParquetChunk<Blob> = {\n  /** Parquet file (PTable) containing column data */\n  data: Blob;\n} & ParquetChunkMapping & Partial<ParquetChunkMetadata>;\n\nexport type ParquetPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('ParquetPartitioned') */\n  type: 'ParquetPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to parquet files */\n  parts: Record<string, Blob>;\n};\n\n/**\n * Union type representing all possible data storage formats for PColumn data.\n * The specific format used depends on data size, access patterns, and performance requirements.\n *\n * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)\n */\nexport type DataInfo<Blob> =\n  | JsonDataInfo\n  | JsonPartitionedDataInfo<Blob>\n  | BinaryPartitionedDataInfo<Blob>\n  | ParquetPartitionedDataInfo<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfo.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfo, false otherwise\n */\nexport function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && data.data !== undefined\n        && typeof data.data === 'object'\n      );\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && data.parts !== undefined\n        && typeof data.parts === 'object'\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Maps blob references in a DataInfo object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfo - The source DataInfo object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfo object with transformed blob references\n */\nexport function mapDataInfo<B1, B2>(\n  dataInfo: ParquetPartitionedDataInfo<B1>,\n  mapFn: (blob: B1) => B2,\n): ParquetPartitionedDataInfo<B2>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: Exclude<DataInfo<B1>, ParquetPartitionedDataInfo<B1>>,\n  mapFn: (blob: B1) => B2,\n): Exclude<DataInfo<B2>, ParquetPartitionedDataInfo<B2>>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2> | undefined {\n  if (dataInfo === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfo.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfo;\n    case 'JsonPartitioned': {\n      // Map each blob in parts\n      const newParts: Record<string, B2> = {};\n      for (const [key, blob] of Object.entries(dataInfo.parts)) {\n        newParts[key] = mapFn(blob);\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      // Map each index and values blob in parts\n      const newParts: Record<string, BinaryChunk<B2>> = {};\n      for (const [key, chunk] of Object.entries(dataInfo.parts)) {\n        newParts[key] = {\n          index: mapFn(chunk.index),\n          values: mapFn(chunk.values),\n        };\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n    case 'ParquetPartitioned': {\n      // Map each blob in parts\n      const newParts: Record<string, B2> = {};\n      for (const [key, blob] of Object.entries(dataInfo.parts)) {\n        newParts[key] = mapFn(blob);\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n  }\n}\n\n/**\n * @param dataInfo - The source DataInfo object\n * @param cb - Callback, function that have access to every blob to visit them all\n * @returns Nothing\n */\nexport function visitDataInfo<B>(\n  dataInfo: DataInfo<B>,\n  cb: (blob: B) => void,\n): void {\n  switch (dataInfo.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      break;\n    case 'JsonPartitioned': {\n      // Visit each blob in parts\n      Object.values(dataInfo.parts).forEach(cb);\n      break;\n    }\n    case 'BinaryPartitioned': {\n      // Visit each index and values blob in parts\n      Object.values(dataInfo.parts).forEach((chunk) => {\n        cb(chunk.index);\n        cb(chunk.values);\n      });\n      break;\n    }\n    case 'ParquetPartitioned': {\n      // Visit each blob in parts\n      Object.values(dataInfo.parts).forEach(cb);\n      break;\n    }\n  }\n}\n\n//\n// Lightway representation for ExplicitJsonData\n//\n\n/**\n * Represents a single key-value entry in a column's explicit data structure.\n * Used when directly instantiating PColumns with explicit data.\n */\nexport type PColumnValuesEntry = {\n  key: PColumnKey;\n  val: PColumnValue;\n};\n\n/**\n * Array of key-value entries representing explicit column data.\n * Used for lightweight explicit instantiation of PColumns.\n */\nexport type PColumnValues = PColumnValuesEntry[];\n\n/**\n * Entry-based representation of JsonDataInfo\n */\nexport interface JsonDataInfoEntries {\n  type: 'Json';\n  keyLength: number;\n  data: PColumnDataEntry<PColumnValue>[];\n}\n\n/**\n * Entry-based representation of JsonPartitionedDataInfo\n */\nexport interface JsonPartitionedDataInfoEntries<Blob> {\n  type: 'JsonPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<Blob>[];\n}\n\n/**\n * Entry-based representation of BinaryPartitionedDataInfo\n */\nexport interface BinaryPartitionedDataInfoEntries<Blob> {\n  type: 'BinaryPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<BinaryChunk<Blob>>[];\n}\n\n/**\n * Entry-based representation of ParquetPartitionedDataInfo\n */\nexport interface ParquetPartitionedDataInfoEntries<Blob> {\n  type: 'ParquetPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<Blob>[];\n}\n/**\n * Union type representing all possible entry-based partitioned data storage formats\n */\nexport type PartitionedDataInfoEntries<Blob> =\n  | JsonPartitionedDataInfoEntries<Blob>\n  | BinaryPartitionedDataInfoEntries<Blob>\n  | ParquetPartitionedDataInfoEntries<Blob>;\n\n/**\n * Union type representing all possible entry-based data storage formats\n */\nexport type DataInfoEntries<Blob> =\n  | JsonDataInfoEntries\n  | PartitionedDataInfoEntries<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfoEntries.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfoEntries, false otherwise\n */\nexport function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && Array.isArray(data.data)\n      );\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && Array.isArray(data.parts)\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.\n *\n * @template Blob - Type parameter representing the storage reference type\n * @param value - The value to check\n * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise\n */\nexport function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob> {\n  if (!isDataInfoEntries(value)) return false;\n  switch (value.type) {\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Converts DataInfo to DataInfoEntries\n *\n * @param dataInfo - The record-based DataInfo object\n * @returns The equivalent entry-based DataInfoEntries object\n */\nexport function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob> {\n  switch (dataInfo.type) {\n    case 'Json': return {\n      type: 'Json',\n      keyLength: dataInfo.keyLength,\n      data: Object.entries(dataInfo.data).map(([keyStr, value]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value } as PColumnDataEntry<PColumnValue>;\n      }),\n    };\n    case 'JsonPartitioned': return {\n      type: 'JsonPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: blob } as PColumnDataEntry<Blob>;\n      }),\n    };\n    case 'BinaryPartitioned': return {\n      type: 'BinaryPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: chunk } as PColumnDataEntry<BinaryChunk<Blob>>;\n      }),\n    };\n    case 'ParquetPartitioned': return {\n      type: 'ParquetPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: blob } as PColumnDataEntry<Blob>;\n      }),\n    };\n    default:\n      assertNever(dataInfo);\n  }\n}\n\n/**\n * Converts DataInfoEntries to DataInfo\n *\n * @param dataInfoEntries - The entry-based DataInfoEntries object\n * @returns The equivalent record-based DataInfo object\n */\nexport function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob> {\n  switch (dataInfoEntries.type) {\n    case 'Json': return {\n      type: 'Json',\n      keyLength: dataInfoEntries.keyLength,\n      data: Object.fromEntries(\n        dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'JsonPartitioned': return {\n      type: 'JsonPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'BinaryPartitioned': return {\n      type: 'BinaryPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'ParquetPartitioned': return {\n      type: 'ParquetPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    default:\n      assertNever(dataInfoEntries);\n  }\n}\n\n/**\n * Maps blob references in a DataInfoEntries object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfoEntries - The source DataInfoEntries object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfoEntries object with transformed blob references\n */\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2>;\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2> | undefined {\n  if (dataInfoEntries === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfoEntries.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfoEntries;\n    case 'JsonPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: mapFn(entry.value),\n      })),\n    };\n    case 'BinaryPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: {\n          index: mapFn(entry.value.index),\n          values: mapFn(entry.value.values),\n        },\n      })),\n    };\n    case 'ParquetPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: mapFn(entry.value),\n      })),\n    };\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/drivers/pframe/data_types.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var spec = require('./spec/spec.cjs');
+
+function isBitSet(bitVector, offset) {
+    const chunkIndex = Math.floor(offset / 8);
+    const mask = 1 << (7 - (offset % 8));
+    return (bitVector[chunkIndex] & mask) > 0;
+}
+function isValueAbsent(vector, row) {
+    return isBitSet(vector.absent, row);
+}
+function isValueNA(vector, row) {
+    if (vector.isNA)
+        return isBitSet(vector.isNA, row);
+    // Check for legacy magic values to support old desktop versions
+    const valueType = vector.type;
+    const value = vector.data[row];
+    switch (valueType) {
+        case spec.ValueType.Int:
+            return value === -2147483648;
+        case spec.ValueType.Long:
+            return value === -9007199254740991n;
+        case spec.ValueType.Float:
+            return Number.isNaN(value);
+        case spec.ValueType.Double:
+            return Number.isNaN(value);
+        case spec.ValueType.String:
+            return value === null;
+        case spec.ValueType.Bytes:
+            return value === null;
+        default:
+            throw Error(`unsupported data type: ${valueType}`);
+    }
+}
+const PTableAbsent = { type: 'absent' };
+/** Type guard for absent value */
+function isPTableAbsent(value) {
+    return typeof value === 'object' && value !== null && 'type' in value && value.type === 'absent';
+}
+const PTableNA = null;
+/** Type guard for NA value */
+function isPTableNA(value) {
+    return value === PTableNA;
+}
+function isPTableValueAxis(value, isNA) {
+    return !(isNA ? isNA(value) : isPTableNA(value));
+}
+function pTableValueImpl(column, row, options) {
+    const valueType = column.type;
+    if (valueType === spec.ValueType.Bytes) {
+        throw Error('Bytes not yet supported');
+    }
+    if (options && 'dataType' in options && options.dataType !== undefined && options.dataType !== valueType) {
+        throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
+    }
+    if (isValueAbsent(column, row)) {
+        return options?.absent !== undefined ? options.absent : PTableAbsent;
+    }
+    if (isValueNA(column, row)) {
+        return options?.na !== undefined ? options.na : PTableNA;
+    }
+    const value = column.data[row];
+    switch (valueType) {
+        case spec.ValueType.Int:
+            return value;
+        case spec.ValueType.Long:
+            return Number(value);
+        case spec.ValueType.Float:
+            return value;
+        case spec.ValueType.Double:
+            return value;
+        case spec.ValueType.String:
+            return value;
+    }
+}
+function pTableValue(column, row, options) {
+    return pTableValueImpl(column, row, options);
+}
+function pTableValueBranded(column, row, options) {
+    return pTableValueImpl(column, row, options);
+}
+
+exports.PTableAbsent = PTableAbsent;
+exports.PTableNA = PTableNA;
+exports.isPTableAbsent = isPTableAbsent;
+exports.isPTableNA = isPTableNA;
+exports.isPTableValueAxis = isPTableValueAxis;
+exports.pTableValue = pTableValue;
+exports.pTableValueBranded = pTableValueBranded;
+//# sourceMappingURL=data_types.cjs.map

package/dist/drivers/pframe/data_types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_types.cjs","sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from '../../branding';\nimport { ValueType } from './spec/spec';\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> =\n  DataType extends typeof ValueType.Int ? PVectorDataInt :\n    DataType extends typeof ValueType.Long ? PVectorDataLong :\n      DataType extends typeof ValueType.Float ? PVectorDataFloat :\n        DataType extends typeof ValueType.Double ? PVectorDataDouble :\n          DataType extends typeof ValueType.String ? PVectorDataString :\n            DataType extends typeof ValueType.Bytes ? PVectorDataBytes :\n              never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN((value as PVectorDataFloat[number]));\n    case ValueType.Double:\n      return Number.isNaN((value as PVectorDataDouble[number]));\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: 'absent' } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === 'object' && value !== null && 'type' in value && value.type === 'absent';\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int ? PTableValueInt :\n    DataType extends typeof ValueType.Long ? PTableValueLong :\n      DataType extends typeof ValueType.Float ? PTableValueFloat :\n        DataType extends typeof ValueType.Double ? PTableValueDouble :\n          DataType extends typeof ValueType.String ? PTableValueString :\n            never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;\nexport type PTableValue<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error('Bytes not yet supported');\n  }\n\n  if (options && 'dataType' in options && options.dataType !== undefined && options.dataType !== valueType) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  }\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  }\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"names":["ValueType"],"mappings":"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"}

package/dist/drivers/pframe/data_types.d.ts

@@ -115,4 +115,3 @@ export type PTableShape = {
     /** Number of rows */
     rows: number;
 };
-//# sourceMappingURL=data_types.d.ts.map

package/dist/drivers/pframe/data_types.js

@@ -0,0 +1,83 @@
+import { ValueType } from './spec/spec.js';
+
+function isBitSet(bitVector, offset) {
+    const chunkIndex = Math.floor(offset / 8);
+    const mask = 1 << (7 - (offset % 8));
+    return (bitVector[chunkIndex] & mask) > 0;
+}
+function isValueAbsent(vector, row) {
+    return isBitSet(vector.absent, row);
+}
+function isValueNA(vector, row) {
+    if (vector.isNA)
+        return isBitSet(vector.isNA, row);
+    // Check for legacy magic values to support old desktop versions
+    const valueType = vector.type;
+    const value = vector.data[row];
+    switch (valueType) {
+        case ValueType.Int:
+            return value === -2147483648;
+        case ValueType.Long:
+            return value === -9007199254740991n;
+        case ValueType.Float:
+            return Number.isNaN(value);
+        case ValueType.Double:
+            return Number.isNaN(value);
+        case ValueType.String:
+            return value === null;
+        case ValueType.Bytes:
+            return value === null;
+        default:
+            throw Error(`unsupported data type: ${valueType}`);
+    }
+}
+const PTableAbsent = { type: 'absent' };
+/** Type guard for absent value */
+function isPTableAbsent(value) {
+    return typeof value === 'object' && value !== null && 'type' in value && value.type === 'absent';
+}
+const PTableNA = null;
+/** Type guard for NA value */
+function isPTableNA(value) {
+    return value === PTableNA;
+}
+function isPTableValueAxis(value, isNA) {
+    return !(isNA ? isNA(value) : isPTableNA(value));
+}
+function pTableValueImpl(column, row, options) {
+    const valueType = column.type;
+    if (valueType === ValueType.Bytes) {
+        throw Error('Bytes not yet supported');
+    }
+    if (options && 'dataType' in options && options.dataType !== undefined && options.dataType !== valueType) {
+        throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
+    }
+    if (isValueAbsent(column, row)) {
+        return options?.absent !== undefined ? options.absent : PTableAbsent;
+    }
+    if (isValueNA(column, row)) {
+        return options?.na !== undefined ? options.na : PTableNA;
+    }
+    const value = column.data[row];
+    switch (valueType) {
+        case ValueType.Int:
+            return value;
+        case ValueType.Long:
+            return Number(value);
+        case ValueType.Float:
+            return value;
+        case ValueType.Double:
+            return value;
+        case ValueType.String:
+            return value;
+    }
+}
+function pTableValue(column, row, options) {
+    return pTableValueImpl(column, row, options);
+}
+function pTableValueBranded(column, row, options) {
+    return pTableValueImpl(column, row, options);
+}
+
+export { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded };
+//# sourceMappingURL=data_types.js.map

package/dist/drivers/pframe/data_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_types.js","sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from '../../branding';\nimport { ValueType } from './spec/spec';\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> =\n  DataType extends typeof ValueType.Int ? PVectorDataInt :\n    DataType extends typeof ValueType.Long ? PVectorDataLong :\n      DataType extends typeof ValueType.Float ? PVectorDataFloat :\n        DataType extends typeof ValueType.Double ? PVectorDataDouble :\n          DataType extends typeof ValueType.String ? PVectorDataString :\n            DataType extends typeof ValueType.Bytes ? PVectorDataBytes :\n              never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN((value as PVectorDataFloat[number]));\n    case ValueType.Double:\n      return Number.isNaN((value as PVectorDataDouble[number]));\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: 'absent' } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === 'object' && value !== null && 'type' in value && value.type === 'absent';\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int ? PTableValueInt :\n    DataType extends typeof ValueType.Long ? PTableValueLong :\n      DataType extends typeof ValueType.Float ? PTableValueFloat :\n        DataType extends typeof ValueType.Double ? PTableValueDouble :\n          DataType extends typeof ValueType.String ? PTableValueString :\n            never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;\nexport type PTableValue<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error('Bytes not yet supported');\n  }\n\n  if (options && 'dataType' in options && options.dataType !== undefined && options.dataType !== valueType) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  }\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  }\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  }\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  }\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"names":[],"mappings":"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"}

package/dist/drivers/pframe/driver.d.ts

@@ -47,4 +47,3 @@ export interface PFrameDriver {
      * */
     getData(handle: PTableHandle, columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
 }
-//# sourceMappingURL=driver.d.ts.map

package/dist/drivers/pframe/find_columns.d.ts

@@ -24,4 +24,3 @@ export interface FindColumnsResponse {
     /** Array of column ids found using request criteria. */
     readonly hits: PColumnIdAndSpec[];
 }
-//# sourceMappingURL=find_columns.d.ts.map

package/dist/drivers/pframe/index.d.ts

@@ -11,4 +11,3 @@ export * from './unique_values';
 export * from './spec';
 export * from './driver';
 export * from './linker_columns';
-//# sourceMappingURL=index.d.ts.map