@milaboratories/pl-model-common 1.31.1 → 1.32.0

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

@@ -1 +1 @@
-{"version":3,"file":"data_info.js","names":[],"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 &\n  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>(dataInfo: DataInfo<B1>, mapFn: (blob: B1) => B2): 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>(dataInfo: DataInfo<B>, cb: (blob: B) => void): 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> = JsonDataInfoEntries | 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 typeof data.keyLength === \"number\" && Array.isArray(data.data);\n    case \"JsonPartitioned\":\n    case \"BinaryPartitioned\":\n    case \"ParquetPartitioned\":\n      return typeof data.partitionKeyLength === \"number\" && Array.isArray(data.parts);\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>(\n  value: unknown,\n): 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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      return {\n        ...dataInfoEntries,\n        parts: dataInfoEntries.parts.map((entry) => ({\n          key: entry.key,\n          value: mapFn(entry.value),\n        })),\n      };\n    case \"BinaryPartitioned\":\n      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\":\n      return {\n        ...dataInfoEntries,\n        parts: dataInfoEntries.parts.map((entry) => ({\n          key: entry.key,\n          value: mapFn(entry.value),\n        })),\n      };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"data_info.js","names":[],"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 &\n  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>(dataInfo: DataInfo<B1>, mapFn: (blob: B1) => B2): 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>(dataInfo: DataInfo<B>, cb: (blob: B) => void): 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> = JsonDataInfoEntries | 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 typeof data.keyLength === \"number\" && Array.isArray(data.data);\n    case \"JsonPartitioned\":\n    case \"BinaryPartitioned\":\n    case \"ParquetPartitioned\":\n      return typeof data.partitionKeyLength === \"number\" && Array.isArray(data.parts);\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>(\n  value: unknown,\n): 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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      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\":\n      return {\n        ...dataInfoEntries,\n        parts: dataInfoEntries.parts.map((entry) => ({\n          key: entry.key,\n          value: mapFn(entry.value),\n        })),\n      };\n    case \"BinaryPartitioned\":\n      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\":\n      return {\n        ...dataInfoEntries,\n        parts: dataInfoEntries.parts.map((entry) => ({\n          key: entry.key,\n          value: mapFn(entry.value),\n        })),\n      };\n  }\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/data_types.cjs

@@ -1,5 +1,4 @@
-const require_spec = require('./spec/spec.cjs');
-
+const require_spec = require("./spec/spec.cjs");
 //#region src/drivers/pframe/data_types.ts
 function isBitSet(bitVector, offset) {
 	const chunkIndex = Math.floor(offset / 8);
@@ -23,13 +22,13 @@ function isValueNA(vector, row) {
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
-	return value === PTableNA;
+	return value === null;
 }
 function pTableValueImpl(column, row, options) {
 	const valueType = column.type;
 	if (valueType === require_spec.ValueType.Bytes) throw Error("Bytes not yet supported");
 	if (options && "dataType" in options && options.dataType !== void 0 && options.dataType !== valueType) throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
-	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
+	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : null;
 	const value = column.data[row];
 	switch (valueType) {
 		case require_spec.ValueType.Int: return value;
@@ -45,10 +44,10 @@ function pTableValue(column, row, options) {
 function pTableValueBranded(column, row, options) {
 	return pTableValueImpl(column, row, options);
 }
-
 //#endregion
 exports.PTableNA = PTableNA;
 exports.isPTableNA = isPTableNA;
 exports.pTableValue = pTableValue;
 exports.pTableValueBranded = pTableValueBranded;
+
 //# sourceMappingURL=data_types.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"data_types.cjs","names":["ValueType"],"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> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? 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 */\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  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\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 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 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\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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 (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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"],"mappings":";;;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAQ,UAAqC;EAC/C,KAAKA,uBAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAKA,uBAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAKA,uBAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAKA,uBAAU,OACb,QAAQ,UAAwC;EAClD,KAAKA,uBAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAqCnB,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAcA,uBAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAO;EACT,KAAKA,uBAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAKA,uBAAU,MACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}
+{"version":3,"file":"data_types.cjs","names":["ValueType"],"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> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? 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 */\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  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\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 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 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\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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 (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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"],"mappings":";;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,aAAAA,UAAU,IACb,QAAQ,UAAqC;EAC/C,KAAKA,aAAAA,UAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAKA,aAAAA,UAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAKA,aAAAA,UAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAKA,aAAAA,UAAU,OACb,QAAQ,UAAwC;EAClD,KAAKA,aAAAA,UAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAA;;AAqCT,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAcA,aAAAA,UAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,KAAA,KACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,KAAA,IAAY,QAAQ,KAAA;CAG7C,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,aAAAA,UAAU,IACb,QAAO;EACT,KAAKA,aAAAA,UAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAKA,aAAAA,UAAU,MACb,QAAO;EACT,KAAKA,aAAAA,UAAU,OACb,QAAO;EACT,KAAKA,aAAAA,UAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"data_types.d.ts","names":[],"sources":["../../../src/drivers/pframe/data_types.ts"],"mappings":"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"}

package/dist/drivers/pframe/data_types.js

@@ -1,5 +1,4 @@
 import { ValueType } from "./spec/spec.js";
-
 //#region src/drivers/pframe/data_types.ts
 function isBitSet(bitVector, offset) {
 	const chunkIndex = Math.floor(offset / 8);
@@ -23,13 +22,13 @@ function isValueNA(vector, row) {
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
-	return value === PTableNA;
+	return value === null;
 }
 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 !== void 0 && options.dataType !== valueType) throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
-	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
+	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : null;
 	const value = column.data[row];
 	switch (valueType) {
 		case ValueType.Int: return value;
@@ -45,7 +44,7 @@ function pTableValue(column, row, options) {
 function pTableValueBranded(column, row, options) {
 	return pTableValueImpl(column, row, options);
 }
-
 //#endregion
 export { PTableNA, isPTableNA, pTableValue, pTableValueBranded };
+
 //# sourceMappingURL=data_types.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"data_types.js","names":[],"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> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? 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 */\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  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\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 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 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\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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 (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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"],"mappings":";;;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAQ,UAAqC;EAC/C,KAAK,UAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAK,UAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAK,UAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAK,UAAU,OACb,QAAQ,UAAwC;EAClD,KAAK,UAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAqCnB,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAc,UAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAO;EACT,KAAK,UAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAK,UAAU,MACb,QAAO;EACT,KAAK,UAAU,OACb,QAAO;EACT,KAAK,UAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}
+{"version":3,"file":"data_types.js","names":[],"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> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? 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 */\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  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\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 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 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\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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 (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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<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<FillNA, DataType> : never;\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<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\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"],"mappings":";;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAQ,UAAqC;EAC/C,KAAK,UAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAK,UAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAK,UAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAK,UAAU,OACb,QAAQ,UAAwC;EAClD,KAAK,UAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAA;;AAqCT,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAc,UAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,KAAA,KACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,KAAA,IAAY,QAAQ,KAAA;CAG7C,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAO;EACT,KAAK,UAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAK,UAAU,MACb,QAAO;EACT,KAAK,UAAU,OACb,QAAO;EACT,KAAK,UAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}

package/dist/drivers/pframe/driver.cjs

@@ -1,7 +1,6 @@
-
 //#region src/drivers/pframe/driver.ts
 function assert() {}
 assert();
-
 //#endregion
+
 //# sourceMappingURL=driver.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"driver.cjs","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport type { PTable } from \"./table\";\nimport type { PFrame, PFrameDef } from \"./pframe\";\nimport type { PColumn } from \"./spec/spec\";\nimport type { PColumnValues, DataInfo } from \"./data_info\";\nimport type { PTableDef, PTableDefV2 } from \"./table_calculate\";\nimport type { AddParameterToAllMethods } from \"./type_util\";\nimport type { PTableShape, PTableVector, TableRange } from \"./data_types\";\nimport type { FindColumnsRequest, FindColumnsResponse } from \"./find_columns\";\nimport type { PObjectId } from \"../../pool\";\nimport type { PColumnIdAndSpec, PColumnSpec } from \"./spec/spec\";\nimport type { CalculateTableDataRequest, CalculateTableDataResponse } from \"./table_calculate\";\nimport type { UniqueValuesRequest, UniqueValuesResponse } from \"./unique_values\";\nimport type { PTableColumnSpec } from \"./table_common\";\n\n/** PFrame handle */\nexport type PFrameHandle = Branded<string, \"PFrame\">;\n\n/** PFrame handle */\nexport type PTableHandle = Branded<string, \"PTable\">;\n\n/** Model-side PFrame service — creates frames/tables from column definitions. */\nexport interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {\n  createPFrame(def: PFrameDef<Col>): PFrameHandle;\n  createPTable(def: PTableDef<Col>): PTableHandle;\n  createPTableV2(def: PTableDefV2<Col>): PTableHandle;\n}\n\n/** Allows to access main data layer features of platforma */\nexport interface PFrameDriver {\n  //\n  // PFrame methods\n  //\n\n  /**\n   * Finds columns given filtering criteria on column name, annotations etc.\n   * and a set of axes ids to find only columns with compatible specs.\n   * */\n  findColumns(handle: PFrameHandle, request: FindColumnsRequest): Promise<FindColumnsResponse>;\n\n  /** Retrieve single column spec */\n  getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null>;\n\n  /** Retrieve information about all columns currently added to the PFrame */\n  listColumns(handle: PFrameHandle): Promise<PColumnIdAndSpec[]>;\n\n  /** Calculates data for the table and returns complete data representation of it */\n  calculateTableData(\n    handle: PFrameHandle,\n    request: CalculateTableDataRequest<PObjectId>,\n    range?: TableRange,\n  ): Promise<CalculateTableDataResponse>;\n\n  /** Calculate set of unique values for a specific axis for the filtered set of records */\n  getUniqueValues(\n    handle: PFrameHandle,\n    request: UniqueValuesRequest,\n  ): Promise<UniqueValuesResponse>;\n\n  //\n  // PTable methods\n  //\n\n  /** Unified table shape */\n  getShape(handle: PTableHandle): Promise<PTableShape>;\n\n  /**\n   * Returns ordered array of table axes specs (primary key \"columns\" in SQL\n   * terms) and data column specs (regular \"columns\" in SQL terms).\n   *\n   * Data for a specific table column can be retrieved using unified indexing\n   * corresponding to elements in this array.\n   *\n   * Axes are always listed first.\n   * */\n  getSpec(handle: PTableHandle): Promise<PTableColumnSpec[]>;\n\n  /**\n   * Retrieve the data from the table. To retrieve only data required, it can be\n   * sliced both horizontally ({@link columnIndices}) and vertically\n   * ({@link range}).\n   *\n   * @param columnIndices unified indices of columns to be retrieved\n   * @param range optionally limit the range of records to retrieve\n   * */\n  getData(\n    handle: PTableHandle,\n    columnIndices: number[],\n    range?: TableRange,\n  ): Promise<PTableVector[]>;\n}\n\n//\n// The following keeps the PFrame driver from above to be in sync with\n// PFrame and PTable interfaces.\n//\n\ntype ExpectedPFrameDriverTypeF = AddParameterToAllMethods<PFrame, [handle: PFrameHandle]>;\ntype ExpectedPFrameDriverTypeT = AddParameterToAllMethods<PTable, [handle: PTableHandle]>;\ntype ExpectedPFrameDriverType = ExpectedPFrameDriverTypeF & ExpectedPFrameDriverTypeT;\n\ntype TypeEqualityGuard<A, B> = Exclude<A, B> | Exclude<B, A>;\nfunction assert<_T extends never>() {}\n\nassert<TypeEqualityGuard<PFrameDriver, ExpectedPFrameDriverType>>();\n"],"mappings":";;AAsGA,SAAS,SAA2B;AAEpC,QAAmE"}
+{"version":3,"file":"driver.cjs","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport type { PTable } from \"./table\";\nimport type { PFrame, PFrameDef } from \"./pframe\";\nimport type { PColumn } from \"./spec/spec\";\nimport type { PColumnValues, DataInfo } from \"./data_info\";\nimport type { PTableDef, PTableDefV2 } from \"./table_calculate\";\nimport type { AddParameterToAllMethods } from \"./type_util\";\nimport type { PTableShape, PTableVector, TableRange } from \"./data_types\";\nimport type { FindColumnsRequest, FindColumnsResponse } from \"./find_columns\";\nimport type { PObjectId } from \"../../pool\";\nimport type { PColumnIdAndSpec, PColumnSpec } from \"./spec/spec\";\nimport type { CalculateTableDataRequest, CalculateTableDataResponse } from \"./table_calculate\";\nimport type { UniqueValuesRequest, UniqueValuesResponse } from \"./unique_values\";\nimport type { PTableColumnSpec } from \"./table_common\";\n\n/** PFrame handle */\nexport type PFrameHandle = Branded<string, \"PFrame\">;\n\n/** PFrame handle */\nexport type PTableHandle = Branded<string, \"PTable\">;\n\n/** Model-side PFrame service — creates frames/tables from column definitions. */\nexport interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {\n  createPFrame(def: PFrameDef<Col>): PFrameHandle;\n  createPTable(def: PTableDef<Col>): PTableHandle;\n  createPTableV2(def: PTableDefV2<Col>): PTableHandle;\n}\n\n/** Allows to access main data layer features of platforma */\nexport interface PFrameDriver {\n  //\n  // PFrame methods\n  //\n\n  /**\n   * Finds columns given filtering criteria on column name, annotations etc.\n   * and a set of axes ids to find only columns with compatible specs.\n   * */\n  findColumns(handle: PFrameHandle, request: FindColumnsRequest): Promise<FindColumnsResponse>;\n\n  /** Retrieve single column spec */\n  getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null>;\n\n  /** Retrieve information about all columns currently added to the PFrame */\n  listColumns(handle: PFrameHandle): Promise<PColumnIdAndSpec[]>;\n\n  /** Calculates data for the table and returns complete data representation of it */\n  calculateTableData(\n    handle: PFrameHandle,\n    request: CalculateTableDataRequest<PObjectId>,\n    range?: TableRange,\n  ): Promise<CalculateTableDataResponse>;\n\n  /** Calculate set of unique values for a specific axis for the filtered set of records */\n  getUniqueValues(\n    handle: PFrameHandle,\n    request: UniqueValuesRequest,\n  ): Promise<UniqueValuesResponse>;\n\n  //\n  // PTable methods\n  //\n\n  /** Unified table shape */\n  getShape(handle: PTableHandle): Promise<PTableShape>;\n\n  /**\n   * Returns ordered array of table axes specs (primary key \"columns\" in SQL\n   * terms) and data column specs (regular \"columns\" in SQL terms).\n   *\n   * Data for a specific table column can be retrieved using unified indexing\n   * corresponding to elements in this array.\n   *\n   * Axes are always listed first.\n   * */\n  getSpec(handle: PTableHandle): Promise<PTableColumnSpec[]>;\n\n  /**\n   * Retrieve the data from the table. To retrieve only data required, it can be\n   * sliced both horizontally ({@link columnIndices}) and vertically\n   * ({@link range}).\n   *\n   * @param columnIndices unified indices of columns to be retrieved\n   * @param range optionally limit the range of records to retrieve\n   * */\n  getData(\n    handle: PTableHandle,\n    columnIndices: number[],\n    range?: TableRange,\n  ): Promise<PTableVector[]>;\n}\n\n//\n// The following keeps the PFrame driver from above to be in sync with\n// PFrame and PTable interfaces.\n//\n\ntype ExpectedPFrameDriverTypeF = AddParameterToAllMethods<PFrame, [handle: PFrameHandle]>;\ntype ExpectedPFrameDriverTypeT = AddParameterToAllMethods<PTable, [handle: PTableHandle]>;\ntype ExpectedPFrameDriverType = ExpectedPFrameDriverTypeF & ExpectedPFrameDriverTypeT;\n\ntype TypeEqualityGuard<A, B> = Exclude<A, B> | Exclude<B, A>;\nfunction assert<_T extends never>() {}\n\nassert<TypeEqualityGuard<PFrameDriver, ExpectedPFrameDriverType>>();\n"],"mappings":";AAsGA,SAAS,SAA2B;AAEpC,QAAmE"}

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

@@ -7,7 +7,6 @@ import { PTableColumnSpec } from "./table_common.js";
 import { CalculateTableDataRequest, CalculateTableDataResponse, PTableDef, PTableDefV2 } from "./table_calculate.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./unique_values.js";
 import { PObjectId } from "../../pool/spec.js";
-import "../../pool/index.js";
 import { PFrameDef } from "./pframe.js";
 
 //#region src/drivers/pframe/driver.d.ts

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

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"mappings":";;;;;;;;;;;;;KAgBY,YAAA,GAAe,OAAA;;KAGf,YAAA,GAAe,OAAA;;UAGV,iBAAA,OAAwB,OAAA,UAAiB,aAAA,GAAgB,QAAA;EACxE,YAAA,CAAa,GAAA,EAAK,SAAA,CAAU,GAAA,IAAO,YAAA;EACnC,YAAA,CAAa,GAAA,EAAK,SAAA,CAAU,GAAA,IAAO,YAAA;EACnC,cAAA,CAAe,GAAA,EAAK,WAAA,CAAY,GAAA,IAAO,YAAA;AAAA;;UAIxB,YAAA;EAPiB;;;;EAgBhC,WAAA,CAAY,MAAA,EAAQ,YAAA,EAAc,OAAA,EAAS,kBAAA,GAAqB,OAAA,CAAQ,mBAAA;EAf5C;EAkB5B,aAAA,CAAc,MAAA,EAAQ,YAAA,EAAc,QAAA,EAAU,SAAA,GAAY,OAAA,CAAQ,WAAA;EAlB/B;EAqBnC,WAAA,CAAY,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,gBAAA;EApBzB;EAuBlB,kBAAA,CACE,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,yBAAA,CAA0B,SAAA,GACnC,KAAA,GAAQ,UAAA,GACP,OAAA,CAAQ,0BAAA;EA1BqB;EA6BhC,eAAA,CACE,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,mBAAA,GACR,OAAA,CAAQ,oBAAA;EAhC4B;EAuCvC,QAAA,CAAS,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,WAAA;EAvCW;;;;;;;;;EAkDnD,OAAA,CAAQ,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,gBAAA;EAnDvC;;;;;;;;EA6DA,OAAA,CACE,MAAA,EAAQ,YAAA,EACR,aAAA,YACA,KAAA,GAAQ,UAAA,GACP,OAAA,CAAQ,YAAA;AAAA"}

package/dist/drivers/pframe/driver.js

@@ -1,6 +1,6 @@
 //#region src/drivers/pframe/driver.ts
 function assert() {}
 assert();
-
 //#endregion
+
 //# sourceMappingURL=driver.js.map

package/dist/drivers/pframe/filter_spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter_spec.d.ts","names":[],"sources":["../../../src/drivers/pframe/filter_spec.ts"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"find_columns.d.ts","names":[],"sources":["../../../src/drivers/pframe/find_columns.ts"],"mappings":";;;;;;AASA;;;;UAAiB,kBAAA;EAEQ;EAAA,SAAd,YAAA,EAAc,YAAA;EAGE;EAAA,SAAhB,cAAA,EAAgB,MAAA;EAQE;;AAI7B;;;;EAJ6B,SAAlB,kBAAA;AAAA;;UAIM,mBAAA;;WAEN,IAAA,EAAM,gBAAA;AAAA"}

package/dist/drivers/pframe/index.cjs

@@ -1,15 +1,15 @@
-const require_data_info = require('./data_info.cjs');
-const require_spec = require('./spec/spec.cjs');
-const require_data_types = require('./data_types.cjs');
-const require_utils = require('./query/utils.cjs');
-require('./query/index.cjs');
-const require_table_calculate = require('./table_calculate.cjs');
-const require_table_common = require('./table_common.cjs');
-const require_ids = require('./spec/ids.cjs');
-const require_anchored = require('./spec/anchored.cjs');
-const require_filtered_column = require('./spec/filtered_column.cjs');
-const require_selectors = require('./spec/selectors.cjs');
-const require_native_id = require('./spec/native_id.cjs');
-require('./spec/index.cjs');
-require('./driver.cjs');
-const require_linker_columns = require('./linker_columns.cjs');
+require("./data_info.cjs");
+require("./spec/spec.cjs");
+require("./data_types.cjs");
+require("./query/utils.cjs");
+require("./query/index.cjs");
+require("./table_calculate.cjs");
+require("./table_common.cjs");
+require("./spec/ids.cjs");
+require("./spec/anchored.cjs");
+require("./spec/filtered_column.cjs");
+require("./spec/selectors.cjs");
+require("./spec/native_id.cjs");
+require("./spec/index.cjs");
+require("./driver.cjs");
+require("./linker_columns.cjs");

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

@@ -1,4 +1,4 @@
-import { Annotation, AnnotationJson, AxesId, AxesSpec, AxisId, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, ColumnValueType, Domain, DomainJson, Metadata, MetadataJson, PAxisName, PColumn, PColumnIdAndSpec, PColumnInfo, PColumnLazy, PColumnName, PColumnSpec, PColumnSpecId, PDataColumnSpec, PUniversalColumnSpec, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./spec/spec.js";
+import { Annotation, AnnotationJson, AxesId, AxesSpec, AxisId, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, ColumnValueType, Domain, DomainJson, Metadata, MetadataJson, PAxisName, PColumn, PColumnIdAndSpec, PColumnInfo, PColumnLazy, PColumnName, PColumnSpec, PColumnSpecId, PDataColumnSpec, PUniversalColumnSpec, Trace, TraceEntry, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./spec/spec.js";
 import { ColumnFilter } from "./column_filter.js";
 import { BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, DataInfo, DataInfoEntries, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, PColumnDataEntry, PColumnKey, PColumnValue, PColumnValues, PColumnValuesEntry, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./data_info.js";
 import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, LegacyAxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./spec/selectors.js";
@@ -11,14 +11,12 @@ import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnS
 import { PTable } from "./table.js";
 import { AnchoredIdDeriver, ResolveAnchorsOptions, resolveAnchors } from "./spec/anchored.js";
 import { NativePObjectId, deriveNativeId } from "./spec/native_id.js";
-import "./spec/index.js";
-import { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin } from "./query/query_spec.js";
+import { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin } from "./query/query_spec.js";
 import { ArtificialColumnJoinEntry, CalculateTableDataRequest, CalculateTableDataResponse, ColumnJoinEntry, ConstantAxisFilter, FullJoin, FullPTableColumnData, InlineColumnJoinEntry, InnerJoin, JoinEntry, OuterJoin, PTableDef, PTableDefV2, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableSorting, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./table_calculate.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./unique_values.js";
-import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin } from "./query/query_data.js";
+import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin } from "./query/query_data.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./query/utils.js";
-import "./query/index.js";
 import { CompositeLinkerMap, LinkerMap } from "./linker_columns.js";
-import { AxisQualification, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./spec_driver.js";
+import { AxisQualification, BuildQueryInput, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./spec_driver.js";
 import { PFrame, PFrameDef } from "./pframe.js";
 import { PFrameDriver, PFrameHandle, PFrameModelDriver, PTableHandle } from "./driver.js";

package/dist/drivers/pframe/index.js

@@ -1,15 +1,15 @@
-import { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./data_info.js";
-import { Annotation, AnnotationJson, Domain, DomainJson, PAxisName, PColumnName, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./spec/spec.js";
-import { PTableNA, isPTableNA, pTableValue, pTableValueBranded } from "./data_types.js";
-import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./query/utils.js";
+import "./data_info.js";
+import "./spec/spec.js";
+import "./data_types.js";
+import "./query/utils.js";
 import "./query/index.js";
-import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./table_calculate.js";
-import { getPTableColumnId } from "./table_common.js";
-import { parseColumnId, stringifyColumnId } from "./spec/ids.js";
-import { AnchoredIdDeriver, resolveAnchors } from "./spec/anchored.js";
-import { isFilteredPColumn } from "./spec/filtered_column.js";
-import { isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./spec/selectors.js";
-import { deriveNativeId } from "./spec/native_id.js";
+import "./table_calculate.js";
+import "./table_common.js";
+import "./spec/ids.js";
+import "./spec/anchored.js";
+import "./spec/filtered_column.js";
+import "./spec/selectors.js";
+import "./spec/native_id.js";
 import "./spec/index.js";
 import "./driver.js";
-import { LinkerMap } from "./linker_columns.js";
+import "./linker_columns.js";

package/dist/drivers/pframe/linker_columns.cjs

@@ -1,6 +1,5 @@
-const require_json = require('../../json.cjs');
-const require_spec = require('./spec/spec.cjs');
-
+const require_json = require("../../json.cjs");
+const require_spec = require("./spec/spec.cjs");
 //#region src/drivers/pframe/linker_columns.ts
 var LinkerMap = class LinkerMap {
 	/** Graph of linkers connected by axes (single or grouped by parents) */
@@ -178,7 +177,7 @@ var LinkerMap = class LinkerMap {
 		return axes.filter((axis) => !parentsSet.has(require_json.canonicalizeJson(require_spec.getAxisId(axis))));
 	}
 };
-
 //#endregion
 exports.LinkerMap = LinkerMap;
+
 //# sourceMappingURL=linker_columns.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"linker_columns.cjs","names":["parseJson","readAnnotationJson","Annotation","getNormalizedAxesList","getArrayFromAxisTree","getAxesTree","canonicalizeJson","getAxisId"],"sources":["../../../src/drivers/pframe/linker_columns.ts"],"sourcesContent":["import { canonicalizeJson, parseJson, type CanonicalizedJson } from \"../../json\";\nimport {\n  Annotation,\n  readAnnotationJson,\n  type AxisSpec,\n  type PColumnIdAndSpec,\n  type AxisSpecNormalized,\n  type AxisId,\n  getAxisId,\n  getNormalizedAxesList,\n  getArrayFromAxisTree,\n  getAxesTree,\n} from \"./spec/spec\";\n\ntype LinkerKey = CanonicalizedJson<AxisId[]>;\nexport type CompositeLinkerMap = Map<\n  LinkerKey,\n  {\n    keyAxesSpec: AxisSpecNormalized[]; // axis specs - source for the key\n    linkWith: Map<LinkerKey, PColumnIdAndSpec>; // for every axis (possibly in group with parents - available by linkers another axes and corresponding linkers)\n  }\n>;\n\ninterface LinkersData {\n  data: CompositeLinkerMap;\n}\nexport class LinkerMap implements LinkersData {\n  /** Graph of linkers connected by axes (single or grouped by parents) */\n  readonly data: CompositeLinkerMap;\n\n  constructor(linkerMap: CompositeLinkerMap) {\n    this.data = linkerMap;\n  }\n\n  get keys() {\n    return this.data.keys();\n  }\n\n  get keyAxesIds() {\n    return [...this.data.keys()].map(parseJson);\n  }\n\n  static fromColumns(columns: PColumnIdAndSpec[]) {\n    const result: CompositeLinkerMap = new Map();\n    for (const linker of columns.filter(\n      (l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn),\n    )) {\n      const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec)); // split input axes into groups by parent links from annotation\n\n      if (groups.length !== 2) {\n        continue; // not a valid linker column\n      }\n      const [left, right] = groups;\n\n      // In case of group:\n      // A - C\n      //  \\_ B _ D\n      // E/\n      // put 2 variants as keys:\n      // A - C\n      //  \\_ B _ D\n      // and\n      // E - B - D\n      const leftKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(left).map(\n        (axis) => {\n          const axes = getArrayFromAxisTree(getAxesTree(axis));\n          const key = canonicalizeJson(axes.map(getAxisId));\n          return [key, axes];\n        },\n      );\n      const rightKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(\n        right,\n      ).map((axis) => {\n        const axes = getArrayFromAxisTree(getAxesTree(axis));\n        const key = canonicalizeJson(axes.map(getAxisId));\n        return [key, axes];\n      });\n\n      for (const [keyLeft, spec] of leftKeyVariants) {\n        if (!result.has(keyLeft)) {\n          result.set(keyLeft, { keyAxesSpec: spec, linkWith: new Map() });\n        }\n      }\n      for (const [keyRight, spec] of rightKeyVariants) {\n        if (!result.has(keyRight)) {\n          result.set(keyRight, { keyAxesSpec: spec, linkWith: new Map() });\n        }\n      }\n      for (const [keyLeft] of leftKeyVariants) {\n        for (const [keyRight] of rightKeyVariants) {\n          result.get(keyLeft)?.linkWith.set(keyRight, linker);\n        }\n      }\n    }\n    return new this(result);\n  }\n\n  /** Get all available nodes of linker graphs if start from sourceAxesKeys */\n  searchAvailableAxesKeys(sourceAxesKeys: LinkerKey[]): Set<LinkerKey> {\n    const startKeys = new Set(sourceAxesKeys);\n    const allAvailableKeys = new Set<LinkerKey>();\n    let nextKeys = sourceAxesKeys;\n    while (nextKeys.length) {\n      const next: LinkerKey[] = [];\n      for (const key of nextKeys) {\n        const node = this.data.get(key);\n        if (!node) continue;\n        for (const availableKey of node.linkWith.keys()) {\n          if (!allAvailableKeys.has(availableKey) && !startKeys.has(availableKey)) {\n            next.push(availableKey);\n            allAvailableKeys.add(availableKey);\n          }\n        }\n      }\n      nextKeys = next;\n    }\n    return allAvailableKeys;\n  }\n\n  /** Get all linker columns that are necessary to reach endKey from startKey */\n  searchLinkerPath(startKey: LinkerKey, endKey: LinkerKey): PColumnIdAndSpec[] {\n    const previous: Record<LinkerKey, LinkerKey> = {};\n    let nextIds = new Set([startKey]);\n    const visited = new Set([startKey]);\n    while (nextIds.size) {\n      const next = new Set<LinkerKey>();\n      for (const nextId of nextIds) {\n        const node = this.data.get(nextId);\n        if (!node) continue;\n        for (const availableId of node.linkWith.keys()) {\n          previous[availableId] = nextId;\n          if (availableId === endKey) {\n            const ids: LinkerKey[] = [];\n            let current = endKey;\n            while (previous[current] !== startKey) {\n              ids.push(current);\n              current = previous[current];\n            }\n            ids.push(current);\n            // Edge (previous[id] -> id) is stored at the \"from\" node in one-directional map\n            return ids.map((id: LinkerKey) => this.data.get(previous[id])!.linkWith.get(id)!);\n          } else if (!visited.has(availableId)) {\n            next.add(availableId);\n            visited.add(availableId);\n          }\n        }\n      }\n      nextIds = next;\n    }\n    return [];\n  }\n\n  getLinkerColumnsForAxes({\n    from: sourceAxes,\n    to: targetAxes,\n    throwWhenNoLinkExists = true,\n  }: {\n    from: AxisSpecNormalized[];\n    to: AxisSpecNormalized[];\n    throwWhenNoLinkExists?: boolean;\n  }): PColumnIdAndSpec[] {\n    // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)\n    const startKeys: LinkerKey[] = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n\n    return Array.from(\n      new Map(\n        LinkerMap.getAxesRoots(targetAxes)\n          .map(LinkerMap.getLinkerKeyFromAxisSpec) // target keys contain all axes to be linked; if some of target axes has parents they must be in the key\n          .flatMap((targetKey) => {\n            const linkers = startKeys\n              .map((startKey) => this.searchLinkerPath(startKey, targetKey))\n              .reduce(\n                (shortestPath, path) =>\n                  (shortestPath.length && shortestPath.length < path.length) || !path.length\n                    ? shortestPath\n                    : path,\n                [] as PColumnIdAndSpec[],\n              )\n              .map((linker) => [linker.columnId, linker] as const);\n            if (!linkers.length && throwWhenNoLinkExists) {\n              throw Error(`Unable to find linker column for ${targetKey}`);\n            }\n            return linkers;\n          }),\n      ).values(),\n    );\n  }\n\n  /** Get list of axisSpecs from keys of linker columns map  */\n  getAxesListFromKeysList(keys: LinkerKey[]): AxisSpecNormalized[] {\n    return Array.from(\n      new Map(\n        keys\n          .flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])\n          .map((axis) => [canonicalizeJson(getAxisId(axis)), axis]),\n      ).values(),\n    );\n  }\n\n  /** Get axes of target axes that are impossible to be linked to source axes with current linker map */\n  getNonLinkableAxes(\n    sourceAxes: AxisSpecNormalized[],\n    targetAxes: AxisSpecNormalized[],\n  ): AxisSpecNormalized[] {\n    const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n    // target keys contain all axes to be linked; if some of target axes has parents they must be in the key\n    const targetKeys = targetAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n\n    const axes = Array.from(\n      new Map(\n        targetAxes\n          .filter((_targetAxis, idx) => {\n            const targetKey = targetKeys[idx];\n            return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);\n          })\n          .flatMap((axis) =>\n            getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [\n              canonicalizeJson(getAxisId(axis)),\n              axis,\n            ]),\n          ),\n      ).values(),\n    );\n    return axes;\n  }\n\n  /** Get all axes that can be connected to sourceAxes by linkers */\n  getReachableByLinkersAxesFromAxesNormalized(\n    sourceAxes: AxisSpecNormalized[],\n    matchAxisIdFn?: (axisIdOfLinker: AxisId, axisIdOfSource: AxisId) => boolean,\n  ): AxisSpecNormalized[] {\n    let startKeys: CanonicalizedJson<AxisId[]>[] = [];\n\n    if (matchAxisIdFn) {\n      const sourceAxisIdsGrouped: AxisId[][] = sourceAxes.map((axis) =>\n        getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId),\n      );\n      for (const sourceAxisIdsGroup of sourceAxisIdsGrouped) {\n        const matched = this.keyAxesIds.find((keyIds: AxisId[]) =>\n          keyIds.every((linkerKeyAxisId) =>\n            sourceAxisIdsGroup.find((sourceAxisId) => matchAxisIdFn(linkerKeyAxisId, sourceAxisId)),\n          ),\n        );\n        if (matched) {\n          startKeys.push(canonicalizeJson(matched));\n        }\n      }\n    } else {\n      startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n    }\n\n    const availableKeys = this.searchAvailableAxesKeys(startKeys);\n    return this.getAxesListFromKeysList([...availableKeys]);\n  }\n\n  getReachableByLinkersAxesFromAxes(\n    sourceAxes: AxisSpec[],\n    matchAxisIdFn?: (axisIdOfLinker: AxisId, axisIdOfSource: AxisId) => boolean,\n  ): AxisSpecNormalized[] {\n    return this.getReachableByLinkersAxesFromAxesNormalized(\n      getNormalizedAxesList(sourceAxes),\n      matchAxisIdFn,\n    );\n  }\n\n  static getLinkerKeyFromAxisSpec(axis: AxisSpecNormalized): LinkerKey {\n    return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));\n  }\n\n  /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.\n     There are no order inside every group. */\n  static getAxesGroups(axesSpec: AxisSpecNormalized[]): AxisSpecNormalized[][] {\n    switch (axesSpec.length) {\n      case 0:\n        return [];\n      case 1:\n        return [[axesSpec[0]]];\n      default:\n        break;\n    }\n\n    const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));\n    const axisParentsIdxs = axesSpec.map(\n      (spec) =>\n        new Set(\n          spec.parentAxesSpec\n            .map((spec) => canonicalizeJson(getAxisId(spec)))\n            .map((el) => {\n              const idx = axisKeys.indexOf(el);\n              if (idx === -1) {\n                throw new Error(\n                  `malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`,\n                );\n              }\n              return idx;\n            }),\n        ),\n    );\n\n    const allIdxs = [...axesSpec.keys()];\n    const groups: number[][] = []; // groups of axis indexes\n\n    const usedIdxs = new Set<number>();\n    let nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));\n    while (nextFreeEl !== undefined) {\n      const currentGroup = [nextFreeEl];\n      usedIdxs.add(nextFreeEl);\n\n      let nextElsOfCurrentGroup = [nextFreeEl];\n      while (nextElsOfCurrentGroup.length) {\n        const next = new Set<number>();\n        for (const groupIdx of nextElsOfCurrentGroup) {\n          const groupElementParents = axisParentsIdxs[groupIdx];\n          allIdxs.forEach((idx) => {\n            if (idx === groupIdx || usedIdxs.has(idx)) {\n              return;\n            }\n            const parents = axisParentsIdxs[idx];\n            if (parents.has(groupIdx) || groupElementParents.has(idx)) {\n              currentGroup.push(idx);\n              next.add(idx);\n              usedIdxs.add(idx);\n            }\n          });\n        }\n        nextElsOfCurrentGroup = [...next];\n      }\n\n      groups.push([...currentGroup]);\n      nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));\n    }\n\n    return groups.map((group) => group.map((idx) => axesSpec[idx]));\n  }\n\n  /** Get all axes that are not parents of any other axis */\n  static getAxesRoots(axes: AxisSpecNormalized[]): AxisSpecNormalized[] {\n    const parentsSet = new Set(\n      axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))),\n    );\n    return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"linker_columns.cjs","names":["parseJson","readAnnotationJson","Annotation","getNormalizedAxesList","getArrayFromAxisTree","getAxesTree","canonicalizeJson","getAxisId"],"sources":["../../../src/drivers/pframe/linker_columns.ts"],"sourcesContent":["import { canonicalizeJson, parseJson, type CanonicalizedJson } from \"../../json\";\nimport {\n  Annotation,\n  readAnnotationJson,\n  type AxisSpec,\n  type PColumnIdAndSpec,\n  type AxisSpecNormalized,\n  type AxisId,\n  getAxisId,\n  getNormalizedAxesList,\n  getArrayFromAxisTree,\n  getAxesTree,\n} from \"./spec/spec\";\n\ntype LinkerKey = CanonicalizedJson<AxisId[]>;\nexport type CompositeLinkerMap = Map<\n  LinkerKey,\n  {\n    keyAxesSpec: AxisSpecNormalized[]; // axis specs - source for the key\n    linkWith: Map<LinkerKey, PColumnIdAndSpec>; // for every axis (possibly in group with parents - available by linkers another axes and corresponding linkers)\n  }\n>;\n\ninterface LinkersData {\n  data: CompositeLinkerMap;\n}\nexport class LinkerMap implements LinkersData {\n  /** Graph of linkers connected by axes (single or grouped by parents) */\n  readonly data: CompositeLinkerMap;\n\n  constructor(linkerMap: CompositeLinkerMap) {\n    this.data = linkerMap;\n  }\n\n  get keys() {\n    return this.data.keys();\n  }\n\n  get keyAxesIds() {\n    return [...this.data.keys()].map(parseJson);\n  }\n\n  static fromColumns(columns: PColumnIdAndSpec[]) {\n    const result: CompositeLinkerMap = new Map();\n    for (const linker of columns.filter(\n      (l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn),\n    )) {\n      const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec)); // split input axes into groups by parent links from annotation\n\n      if (groups.length !== 2) {\n        continue; // not a valid linker column\n      }\n      const [left, right] = groups;\n\n      // In case of group:\n      // A - C\n      //  \\_ B _ D\n      // E/\n      // put 2 variants as keys:\n      // A - C\n      //  \\_ B _ D\n      // and\n      // E - B - D\n      const leftKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(left).map(\n        (axis) => {\n          const axes = getArrayFromAxisTree(getAxesTree(axis));\n          const key = canonicalizeJson(axes.map(getAxisId));\n          return [key, axes];\n        },\n      );\n      const rightKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(\n        right,\n      ).map((axis) => {\n        const axes = getArrayFromAxisTree(getAxesTree(axis));\n        const key = canonicalizeJson(axes.map(getAxisId));\n        return [key, axes];\n      });\n\n      for (const [keyLeft, spec] of leftKeyVariants) {\n        if (!result.has(keyLeft)) {\n          result.set(keyLeft, { keyAxesSpec: spec, linkWith: new Map() });\n        }\n      }\n      for (const [keyRight, spec] of rightKeyVariants) {\n        if (!result.has(keyRight)) {\n          result.set(keyRight, { keyAxesSpec: spec, linkWith: new Map() });\n        }\n      }\n      for (const [keyLeft] of leftKeyVariants) {\n        for (const [keyRight] of rightKeyVariants) {\n          result.get(keyLeft)?.linkWith.set(keyRight, linker);\n        }\n      }\n    }\n    return new this(result);\n  }\n\n  /** Get all available nodes of linker graphs if start from sourceAxesKeys */\n  searchAvailableAxesKeys(sourceAxesKeys: LinkerKey[]): Set<LinkerKey> {\n    const startKeys = new Set(sourceAxesKeys);\n    const allAvailableKeys = new Set<LinkerKey>();\n    let nextKeys = sourceAxesKeys;\n    while (nextKeys.length) {\n      const next: LinkerKey[] = [];\n      for (const key of nextKeys) {\n        const node = this.data.get(key);\n        if (!node) continue;\n        for (const availableKey of node.linkWith.keys()) {\n          if (!allAvailableKeys.has(availableKey) && !startKeys.has(availableKey)) {\n            next.push(availableKey);\n            allAvailableKeys.add(availableKey);\n          }\n        }\n      }\n      nextKeys = next;\n    }\n    return allAvailableKeys;\n  }\n\n  /** Get all linker columns that are necessary to reach endKey from startKey */\n  searchLinkerPath(startKey: LinkerKey, endKey: LinkerKey): PColumnIdAndSpec[] {\n    const previous: Record<LinkerKey, LinkerKey> = {};\n    let nextIds = new Set([startKey]);\n    const visited = new Set([startKey]);\n    while (nextIds.size) {\n      const next = new Set<LinkerKey>();\n      for (const nextId of nextIds) {\n        const node = this.data.get(nextId);\n        if (!node) continue;\n        for (const availableId of node.linkWith.keys()) {\n          previous[availableId] = nextId;\n          if (availableId === endKey) {\n            const ids: LinkerKey[] = [];\n            let current = endKey;\n            while (previous[current] !== startKey) {\n              ids.push(current);\n              current = previous[current];\n            }\n            ids.push(current);\n            // Edge (previous[id] -> id) is stored at the \"from\" node in one-directional map\n            return ids.map((id: LinkerKey) => this.data.get(previous[id])!.linkWith.get(id)!);\n          } else if (!visited.has(availableId)) {\n            next.add(availableId);\n            visited.add(availableId);\n          }\n        }\n      }\n      nextIds = next;\n    }\n    return [];\n  }\n\n  getLinkerColumnsForAxes({\n    from: sourceAxes,\n    to: targetAxes,\n    throwWhenNoLinkExists = true,\n  }: {\n    from: AxisSpecNormalized[];\n    to: AxisSpecNormalized[];\n    throwWhenNoLinkExists?: boolean;\n  }): PColumnIdAndSpec[] {\n    // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)\n    const startKeys: LinkerKey[] = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n\n    return Array.from(\n      new Map(\n        LinkerMap.getAxesRoots(targetAxes)\n          .map(LinkerMap.getLinkerKeyFromAxisSpec) // target keys contain all axes to be linked; if some of target axes has parents they must be in the key\n          .flatMap((targetKey) => {\n            const linkers = startKeys\n              .map((startKey) => this.searchLinkerPath(startKey, targetKey))\n              .reduce(\n                (shortestPath, path) =>\n                  (shortestPath.length && shortestPath.length < path.length) || !path.length\n                    ? shortestPath\n                    : path,\n                [] as PColumnIdAndSpec[],\n              )\n              .map((linker) => [linker.columnId, linker] as const);\n            if (!linkers.length && throwWhenNoLinkExists) {\n              throw Error(`Unable to find linker column for ${targetKey}`);\n            }\n            return linkers;\n          }),\n      ).values(),\n    );\n  }\n\n  /** Get list of axisSpecs from keys of linker columns map  */\n  getAxesListFromKeysList(keys: LinkerKey[]): AxisSpecNormalized[] {\n    return Array.from(\n      new Map(\n        keys\n          .flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])\n          .map((axis) => [canonicalizeJson(getAxisId(axis)), axis]),\n      ).values(),\n    );\n  }\n\n  /** Get axes of target axes that are impossible to be linked to source axes with current linker map */\n  getNonLinkableAxes(\n    sourceAxes: AxisSpecNormalized[],\n    targetAxes: AxisSpecNormalized[],\n  ): AxisSpecNormalized[] {\n    const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n    // target keys contain all axes to be linked; if some of target axes has parents they must be in the key\n    const targetKeys = targetAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n\n    const axes = Array.from(\n      new Map(\n        targetAxes\n          .filter((_targetAxis, idx) => {\n            const targetKey = targetKeys[idx];\n            return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);\n          })\n          .flatMap((axis) =>\n            getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [\n              canonicalizeJson(getAxisId(axis)),\n              axis,\n            ]),\n          ),\n      ).values(),\n    );\n    return axes;\n  }\n\n  /** Get all axes that can be connected to sourceAxes by linkers */\n  getReachableByLinkersAxesFromAxesNormalized(\n    sourceAxes: AxisSpecNormalized[],\n    matchAxisIdFn?: (axisIdOfLinker: AxisId, axisIdOfSource: AxisId) => boolean,\n  ): AxisSpecNormalized[] {\n    let startKeys: CanonicalizedJson<AxisId[]>[] = [];\n\n    if (matchAxisIdFn) {\n      const sourceAxisIdsGrouped: AxisId[][] = sourceAxes.map((axis) =>\n        getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId),\n      );\n      for (const sourceAxisIdsGroup of sourceAxisIdsGrouped) {\n        const matched = this.keyAxesIds.find((keyIds: AxisId[]) =>\n          keyIds.every((linkerKeyAxisId) =>\n            sourceAxisIdsGroup.find((sourceAxisId) => matchAxisIdFn(linkerKeyAxisId, sourceAxisId)),\n          ),\n        );\n        if (matched) {\n          startKeys.push(canonicalizeJson(matched));\n        }\n      }\n    } else {\n      startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);\n    }\n\n    const availableKeys = this.searchAvailableAxesKeys(startKeys);\n    return this.getAxesListFromKeysList([...availableKeys]);\n  }\n\n  getReachableByLinkersAxesFromAxes(\n    sourceAxes: AxisSpec[],\n    matchAxisIdFn?: (axisIdOfLinker: AxisId, axisIdOfSource: AxisId) => boolean,\n  ): AxisSpecNormalized[] {\n    return this.getReachableByLinkersAxesFromAxesNormalized(\n      getNormalizedAxesList(sourceAxes),\n      matchAxisIdFn,\n    );\n  }\n\n  static getLinkerKeyFromAxisSpec(axis: AxisSpecNormalized): LinkerKey {\n    return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));\n  }\n\n  /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.\n     There are no order inside every group. */\n  static getAxesGroups(axesSpec: AxisSpecNormalized[]): AxisSpecNormalized[][] {\n    switch (axesSpec.length) {\n      case 0:\n        return [];\n      case 1:\n        return [[axesSpec[0]]];\n      default:\n        break;\n    }\n\n    const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));\n    const axisParentsIdxs = axesSpec.map(\n      (spec) =>\n        new Set(\n          spec.parentAxesSpec\n            .map((spec) => canonicalizeJson(getAxisId(spec)))\n            .map((el) => {\n              const idx = axisKeys.indexOf(el);\n              if (idx === -1) {\n                throw new Error(\n                  `malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`,\n                );\n              }\n              return idx;\n            }),\n        ),\n    );\n\n    const allIdxs = [...axesSpec.keys()];\n    const groups: number[][] = []; // groups of axis indexes\n\n    const usedIdxs = new Set<number>();\n    let nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));\n    while (nextFreeEl !== undefined) {\n      const currentGroup = [nextFreeEl];\n      usedIdxs.add(nextFreeEl);\n\n      let nextElsOfCurrentGroup = [nextFreeEl];\n      while (nextElsOfCurrentGroup.length) {\n        const next = new Set<number>();\n        for (const groupIdx of nextElsOfCurrentGroup) {\n          const groupElementParents = axisParentsIdxs[groupIdx];\n          allIdxs.forEach((idx) => {\n            if (idx === groupIdx || usedIdxs.has(idx)) {\n              return;\n            }\n            const parents = axisParentsIdxs[idx];\n            if (parents.has(groupIdx) || groupElementParents.has(idx)) {\n              currentGroup.push(idx);\n              next.add(idx);\n              usedIdxs.add(idx);\n            }\n          });\n        }\n        nextElsOfCurrentGroup = [...next];\n      }\n\n      groups.push([...currentGroup]);\n      nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));\n    }\n\n    return groups.map((group) => group.map((idx) => axesSpec[idx]));\n  }\n\n  /** Get all axes that are not parents of any other axis */\n  static getAxesRoots(axes: AxisSpecNormalized[]): AxisSpecNormalized[] {\n    const parentsSet = new Set(\n      axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))),\n    );\n    return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));\n  }\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/linker_columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linker_columns.d.ts","names":[],"sources":["../../../src/drivers/pframe/linker_columns.ts"],"mappings":";;;;KAcK,SAAA,GAAY,iBAAA,CAAkB,MAAA;AAAA,KACvB,kBAAA,GAAqB,GAAA,CAC/B,SAAA;EAEE,WAAA,EAAa,kBAAA;EACb,QAAA,EAAU,GAAA,CAAI,SAAA,EAAW,gBAAA;AAAA;AAAA,UAInB,WAAA;EACR,IAAA,EAAM,kBAAA;AAAA;AAAA,cAEK,SAAA,YAAqB,WAAA;;WAEvB,IAAA,EAAM,kBAAA;cAEH,SAAA,EAAW,kBAAA;EAAA,IAInB,IAAA,CAAA,GAAI,WAAA;;;MAIJ,UAAA,CAAA,GAAU,MAAA;EAAA,OAIP,WAAA,CAAY,OAAA,EAAS,gBAAA,KAAkB,SAAA;EA3BZ;EAmFlC,uBAAA,CAAwB,cAAA,EAAgB,SAAA,KAAc,GAAA,CAAI,SAAA;EAlF1D;EAwGA,gBAAA,CAAiB,QAAA,EAAU,SAAA,EAAW,MAAA,EAAQ,SAAA,GAAY,gBAAA;EAgC1D,uBAAA,CAAA;IACE,IAAA,EAAM,UAAA;IACN,EAAA,EAAI,UAAA;IACJ;EAAA;IAEA,IAAA,EAAM,kBAAA;IACN,EAAA,EAAI,kBAAA;IACJ,qBAAA;EAAA,IACE,gBAAA;EA7IuC;EA0K3C,uBAAA,CAAwB,IAAA,EAAM,SAAA,KAAc,kBAAA;EAtKpC;EAiLR,kBAAA,CACE,UAAA,EAAY,kBAAA,IACZ,UAAA,EAAY,kBAAA,KACX,kBAAA;;EAwBH,2CAAA,CACE,UAAA,EAAY,kBAAA,IACZ,aAAA,IAAiB,cAAA,EAAgB,MAAA,EAAQ,cAAA,EAAgB,MAAA,eACxD,kBAAA;EAyBH,iCAAA,CACE,UAAA,EAAY,QAAA,IACZ,aAAA,IAAiB,cAAA,EAAgB,MAAA,EAAQ,cAAA,EAAgB,MAAA,eACxD,kBAAA;EAAA,OAOI,wBAAA,CAAyB,IAAA,EAAM,kBAAA,GAAqB,SAAA;EA/OtC;;EAAA,OAqPd,aAAA,CAAc,QAAA,EAAU,kBAAA,KAAuB,kBAAA;EAjP/B;EAAA,OAkThB,YAAA,CAAa,IAAA,EAAM,kBAAA,KAAuB,kBAAA;AAAA"}

package/dist/drivers/pframe/linker_columns.js

@@ -1,6 +1,5 @@
 import { canonicalizeJson, parseJson } from "../../json.js";
 import { Annotation, getArrayFromAxisTree, getAxesTree, getAxisId, getNormalizedAxesList, readAnnotationJson } from "./spec/spec.js";
-
 //#region src/drivers/pframe/linker_columns.ts
 var LinkerMap = class LinkerMap {
 	/** Graph of linkers connected by axes (single or grouped by parents) */
@@ -178,7 +177,7 @@ var LinkerMap = class LinkerMap {
 		return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));
 	}
 };
-
 //#endregion
 export { LinkerMap };
+
 //# sourceMappingURL=linker_columns.js.map