@milaboratories/pl-model-common 1.29.0 → 1.31.0

package/dist/bmodel/block_config.d.ts

@@ -1,4 +1,5 @@
 import { BlockCodeFeatureFlags } from "../flags/block_flags.js";
+import "../flags/index.js";
 import { BlockCodeWithInfo, Code } from "./code.js";
 import { BlockRenderingMode } from "./types.js";
 

package/dist/bmodel/code.d.ts

@@ -1,4 +1,5 @@
 import { BlockCodeFeatureFlags } from "../flags/block_flags.js";
+import "../flags/index.js";
 import { z } from "zod";
 
 //#region src/bmodel/code.d.ts

package/dist/driver_kit.d.ts

@@ -1,8 +1,8 @@
 import { BlobDriver } from "./drivers/blob.js";
 import { LogsDriver } from "./drivers/log.js";
-import { PFrameDriver } from "./drivers/pframe/driver.js";
 import { LsDriver } from "./drivers/ls.js";
 import "./drivers/index.js";
+import { PFrameDriver } from "./drivers/pframe/driver.js";
 
 //#region src/driver_kit.d.ts
 /** Set of all drivers exposed in UI SDK via the platforma object. */

package/dist/drivers/index.d.ts

@@ -3,28 +3,28 @@ import { ArchiveFormat, BlobToURLDriver, BlockUIURL, FolderURL, FrontendDriver,
 import { BlobDriver, BlobHandleAndSize, ContentHandler, GetContentOptions, LocalBlobHandle, LocalBlobHandleAndSize, RangeBytes, RemoteBlobHandle, RemoteBlobHandleAndSize, newRangeBytesOpt, validateRangeBytes } from "./blob.js";
 import { ImportProgress, ImportStatus } from "./upload.js";
 import { AnyLogHandle, LiveLogHandle, LogsDriver, ProgressLogWithInfo, ReadyLogHandle, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, isLiveLog } from "./log.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, 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 } from "./pframe/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, 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 "./pframe/spec/spec.js";
 import { ColumnFilter } from "./pframe/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 "./pframe/data_info.js";
 import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, LegacyAxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./pframe/spec/selectors.js";
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./pframe/spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./pframe/spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./pframe/filter_spec.js";
-import { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
+import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./pframe/find_columns.js";
 import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./pframe/table_common.js";
+import { PTable } from "./pframe/table.js";
 import { AnchoredIdDeriver, ResolveAnchorsOptions, resolveAnchors } from "./pframe/spec/anchored.js";
 import { NativePObjectId, deriveNativeId } from "./pframe/spec/native_id.js";
 import { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin } from "./pframe/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 "./pframe/table_calculate.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./pframe/unique_values.js";
-import { PFrame, PFrameDef } from "./pframe/pframe.js";
-import { PTable } from "./pframe/table.js";
 import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin } from "./pframe/query/query_data.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./pframe/query/utils.js";
-import { PFrameDriver, PFrameHandle, PTableHandle } from "./pframe/driver.js";
 import { CompositeLinkerMap, LinkerMap } from "./pframe/linker_columns.js";
-import { AxisQualification, ColumnAxesWithQualifications, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./pframe/spec_driver.js";
+import { AxisQualification, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./pframe/spec_driver.js";
 import "./pframe/index.js";
 import { FileRange, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ListFilesResult, LocalImportFileHandle, LsDriver, LsEntry, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload } from "./ls.js";
-import { ChunkedStreamReader, ChunkedStreamReaderOptions, ErrorHandlerStatus } from "./ChunkedStreamReader.js";
+import { ChunkedStreamReader, ChunkedStreamReaderOptions, ErrorHandlerStatus } from "./ChunkedStreamReader.js";
+import { PFrame, PFrameDef } from "./pframe/pframe.js";
+import { PFrameDriver, PFrameHandle, PFrameModelDriver, PTableHandle } from "./pframe/driver.js";

package/dist/drivers/index.js

@@ -3,8 +3,8 @@ import { RangeBytes, newRangeBytesOpt, validateRangeBytes } from "./blob.js";
 import { isLiveLog } from "./log.js";
 import { getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload } from "./ls.js";
 import { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./pframe/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 } from "./pframe/spec/spec.js";
-import { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./pframe/data_types.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 "./pframe/spec/spec.js";
+import { PTableNA, isPTableNA, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./pframe/query/utils.js";
 import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./pframe/table_calculate.js";
 import { getPTableColumnId } from "./pframe/table_common.js";

package/dist/drivers/pframe/data_types.cjs

@@ -6,9 +6,6 @@ function isBitSet(bitVector, offset) {
 	const mask = 1 << 7 - offset % 8;
 	return (bitVector[chunkIndex] & mask) > 0;
 }
-function isValueAbsent(vector, row) {
-	return isBitSet(vector.absent, row);
-}
 function isValueNA(vector, row) {
 	if (vector.isNA) return isBitSet(vector.isNA, row);
 	const valueType = vector.type;
@@ -23,24 +20,15 @@ function isValueNA(vector, row) {
 		default: throw Error(`unsupported data type: ${valueType}`);
 	}
 }
-const PTableAbsent = { type: "absent" };
-/** Type guard for absent value */
-function isPTableAbsent(value) {
-	return typeof value === "object" && value !== null && "type" in value && value.type === "absent";
-}
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
 	return value === PTableNA;
 }
-function isPTableValueAxis(value, isNA) {
-	return !(isNA ? isNA(value) : isPTableNA(value));
-}
 function pTableValueImpl(column, row, options) {
 	const valueType = column.type;
 	if (valueType === 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 (isValueAbsent(column, row)) return options?.absent !== void 0 ? options.absent : PTableAbsent;
 	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
 	const value = column.data[row];
 	switch (valueType) {
@@ -59,11 +47,8 @@ function pTableValueBranded(column, row, options) {
 }
 
 //#endregion
-exports.PTableAbsent = PTableAbsent;
 exports.PTableNA = PTableNA;
-exports.isPTableAbsent = isPTableAbsent;
 exports.isPTableNA = isPTableNA;
-exports.isPTableValueAxis = isPTableValueAxis;
 exports.pTableValue = pTableValue;
 exports.pTableValueBranded = pTableValueBranded;
 //# sourceMappingURL=data_types.cjs.map

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

@@ -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, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: \"absent\" } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === \"object\" && value !== null && \"type\" in value && value.type === \"absent\";\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\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<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\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 (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported\n  ? PTableValueBranded<PTableAbsent, PTableNA, DataType>\n  : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AAiDA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,cAAc,QAAsB,KAAsB;AACjE,QAAO,SAAS,OAAO,QAAQ,IAAI;;AAGrC,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,eAAe,EAAE,MAAM,UAAU;;AAI9C,SAAgB,eAAe,OAAuC;AACpE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,MAAM,SAAS;;AAG1F,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAiDnB,SAAgB,kBAKd,OACA,MAC4C;AAC5C,QAAO,EAAE,OAAO,KAAK,MAAM,GAAG,WAAW,MAAM;;AAGjD,SAAS,gBAKP,QACA,KACA,SAKA;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,cAAc,QAAQ,IAAI,CAC5B,QAAO,SAAS,WAAW,SAAY,QAAQ,SAAS;AAG1D,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;;;AAwDd,SAAgB,YAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAwD9C,SAAgB,mBAKd,QACA,KACA,SAKA;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,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"}

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

@@ -11,30 +11,18 @@ type PVectorDataBytes = (null | Uint8Array)[];
 type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int ? PVectorDataInt : DataType extends typeof ValueType.Long ? PVectorDataLong : DataType extends typeof ValueType.Float ? PVectorDataFloat : DataType extends typeof ValueType.Double ? PVectorDataDouble : DataType extends typeof ValueType.String ? PVectorDataString : DataType extends typeof ValueType.Bytes ? PVectorDataBytes : never;
 type PVectorData = PVectorDataTyped<ValueType>;
 type PTableVectorTyped<DataType extends ValueType> = {
-  /** Stored data type */readonly type: DataType; /** Values for present positions, absent positions have NA values */
+  /** Stored data type */readonly type: DataType; /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
   /**
    * Encoded bit array marking some elements of this vector as NA,
    * call {@link bitSet} to read the data.
    * In old desktop versions NA values are encoded as magic values in data array.
    * */
-  readonly isNA?: Uint8Array;
-  /**
-   * Encoded bit array marking some elements of this vector as absent,
-   * call {@link bitSet} to read the data.
-   * */
-  readonly absent: Uint8Array;
+  readonly isNA?: Uint8Array; /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  readonly absent?: Uint8Array;
 };
-/** Table column data in comparison to the data stored in a separate PColumn
- * may have some of the values "absent", i.e. as a result of missing record in
- * outer join operation. This information is encoded in {@link absent} field. */
+/** Table column data */
 type PTableVector = PTableVectorTyped<ValueType>;
-declare const PTableAbsent: {
-  readonly type: "absent";
-};
-type PTableAbsent = typeof PTableAbsent;
-/** Type guard for absent value */
-declare function isPTableAbsent(value: unknown): value is PTableAbsent;
 declare const PTableNA: null;
 type PTableNA = typeof PTableNA;
 /** Type guard for NA value */
@@ -47,60 +35,26 @@ type PTableValueDouble = number;
 type PTableValueString = string;
 type PTableValueData<DataType extends ValueTypeSupported> = DataType extends typeof ValueType.Int ? PTableValueInt : DataType extends typeof ValueType.Long ? PTableValueLong : DataType extends typeof ValueType.Float ? PTableValueFloat : DataType extends typeof ValueType.Double ? PTableValueDouble : DataType extends typeof ValueType.String ? PTableValueString : never;
 type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
-type PTableValue<Absent = PTableAbsent, NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = Absent | NA | PTableValueData<DataType>;
-type PTableValueBranded<Absent = PTableAbsent, NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = Absent | NA | PTableValueDataBranded<DataType>;
-type PTableValueAxis<Absent = PTableAbsent, DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValue<Absent, never, DataType>;
-declare function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(value: PTableValue<Absent, NA, DataType>, isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA): value is PTableValueAxis<Absent, DataType>;
-declare function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(value: PTableValue<Absent, PTableNA, DataType>): value is PTableValueAxis<Absent, DataType>;
+type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueData<DataType>;
+type PTableValueBranded<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueDataBranded<DataType>;
+type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValueData<DataType>;
 /** Read PTableValue from PTable column at specified row */
-declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;
-declare function pTableValue<FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-}): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;
+declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;
 declare function pTableValue<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;
-declare function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;
-declare function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  dataType: DataType;
-}): PTableValue<FillAbsent, PTableNA>;
+}): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;
 declare function pTableValue<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
-}): PTableValue<PTableAbsent, FillNA, DataType>;
-declare function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-  dataType: DataType;
-}): PTableValue<FillAbsent, FillNA, DataType>;
-declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, PTableNA, DataType> : never;
-declare function pTableValueBranded<FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-}): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;
+}): PTableValue<FillNA, DataType>;
+declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;
 declare function pTableValueBranded<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;
-declare function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;
-declare function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  dataType: DataType;
-}): PTableValueBranded<FillAbsent, PTableNA>;
+}): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;
 declare function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
-}): PTableValueBranded<PTableAbsent, FillNA, DataType>;
-declare function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-  dataType: DataType;
-}): PTableValueBranded<FillAbsent, FillNA, DataType>;
+}): PTableValueBranded<FillNA, DataType>;
 /** Used in requests to partially retrieve table's data */
 type TableRange = {
   /** Index of the first record to retrieve */readonly offset: number; /** Block length */
@@ -112,5 +66,5 @@ type PTableShape = {
   rows: number;
 };
 //#endregion
-export { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded };
+export { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded };
 //# sourceMappingURL=data_types.d.ts.map

package/dist/drivers/pframe/data_types.js

@@ -6,9 +6,6 @@ function isBitSet(bitVector, offset) {
 	const mask = 1 << 7 - offset % 8;
 	return (bitVector[chunkIndex] & mask) > 0;
 }
-function isValueAbsent(vector, row) {
-	return isBitSet(vector.absent, row);
-}
 function isValueNA(vector, row) {
 	if (vector.isNA) return isBitSet(vector.isNA, row);
 	const valueType = vector.type;
@@ -23,24 +20,15 @@ function isValueNA(vector, row) {
 		default: throw Error(`unsupported data type: ${valueType}`);
 	}
 }
-const PTableAbsent = { type: "absent" };
-/** Type guard for absent value */
-function isPTableAbsent(value) {
-	return typeof value === "object" && value !== null && "type" in value && value.type === "absent";
-}
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
 	return value === PTableNA;
 }
-function isPTableValueAxis(value, isNA) {
-	return !(isNA ? isNA(value) : isPTableNA(value));
-}
 function pTableValueImpl(column, row, options) {
 	const valueType = column.type;
 	if (valueType === ValueType.Bytes) throw Error("Bytes not yet supported");
 	if (options && "dataType" in options && options.dataType !== void 0 && options.dataType !== valueType) throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
-	if (isValueAbsent(column, row)) return options?.absent !== void 0 ? options.absent : PTableAbsent;
 	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
 	const value = column.data[row];
 	switch (valueType) {
@@ -59,5 +47,5 @@ function pTableValueBranded(column, row, options) {
 }
 
 //#endregion
-export { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded };
+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, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: \"absent\" } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === \"object\" && value !== null && \"type\" in value && value.type === \"absent\";\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\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<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\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 (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported\n  ? PTableValueBranded<PTableAbsent, PTableNA, DataType>\n  : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AAiDA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,cAAc,QAAsB,KAAsB;AACjE,QAAO,SAAS,OAAO,QAAQ,IAAI;;AAGrC,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,eAAe,EAAE,MAAM,UAAU;;AAI9C,SAAgB,eAAe,OAAuC;AACpE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,MAAM,SAAS;;AAG1F,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAiDnB,SAAgB,kBAKd,OACA,MAC4C;AAC5C,QAAO,EAAE,OAAO,KAAK,MAAM,GAAG,WAAW,MAAM;;AAGjD,SAAS,gBAKP,QACA,KACA,SAKA;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,cAAc,QAAQ,IAAI,CAC5B,QAAO,SAAS,WAAW,SAAY,QAAQ,SAAS;AAG1D,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;;;AAwDd,SAAgB,YAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAwD9C,SAAgB,mBAKd,QACA,KACA,SAKA;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,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"}

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 } from \"./pframe\";\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/** 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":";;AA4FA,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

@@ -1,18 +1,26 @@
 import { Branded } from "../../branding.js";
-import { PObjectId } from "../../pool/spec.js";
-import "../../pool/index.js";
-import { PColumnIdAndSpec, PColumnSpec } from "./spec/spec.js";
+import { PColumn, PColumnIdAndSpec, PColumnSpec } from "./spec/spec.js";
+import { DataInfo, PColumnValues } from "./data_info.js";
 import { PTableShape, PTableVector, TableRange } from "./data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./find_columns.js";
 import { PTableColumnSpec } from "./table_common.js";
-import { CalculateTableDataRequest, CalculateTableDataResponse } from "./table_calculate.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
 /** PFrame handle */
 type PFrameHandle = Branded<string, "PFrame">;
 /** PFrame handle */
 type PTableHandle = Branded<string, "PTable">;
+/** Model-side PFrame service — creates frames/tables from column definitions. */
+interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
+  createPFrame(def: PFrameDef<Col>): PFrameHandle;
+  createPTable(def: PTableDef<Col>): PTableHandle;
+  createPTableV2(def: PTableDefV2<Col>): PTableHandle;
+}
 /** Allows to access main data layer features of platforma */
 interface PFrameDriver {
   /**
@@ -51,5 +59,5 @@ interface PFrameDriver {
   getData(handle: PTableHandle, columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
 }
 //#endregion
-export { PFrameDriver, PFrameHandle, PTableHandle };
+export { PFrameDriver, PFrameHandle, PFrameModelDriver, PTableHandle };
 //# sourceMappingURL=driver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"driver.js","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport type { PTable } from \"./table\";\nimport type { PFrame } from \"./pframe\";\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/** 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":";AA4FA,SAAS,SAA2B;AAEpC,QAAmE"}
+{"version":3,"file":"driver.js","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/index.d.ts

@@ -1,24 +1,24 @@
-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 } 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, 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";
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./filter_spec.js";
-import { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./data_types.js";
+import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./find_columns.js";
 import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./table_common.js";
+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 { 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 { PFrame, PFrameDef } from "./pframe.js";
-import { PTable } from "./table.js";
 import { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, 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 { PFrameDriver, PFrameHandle, PTableHandle } from "./driver.js";
 import { CompositeLinkerMap, LinkerMap } from "./linker_columns.js";
-import { AxisQualification, ColumnAxesWithQualifications, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher } from "./spec_driver.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 { PFrame, PFrameDef } from "./pframe.js";
+import { PFrameDriver, PFrameHandle, PFrameModelDriver, PTableHandle } from "./driver.js";

package/dist/drivers/pframe/index.js

@@ -1,6 +1,6 @@
 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 } from "./spec/spec.js";
-import { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./data_types.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 "./query/index.js";
 import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./table_calculate.js";

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

@@ -1,10 +1,10 @@
-import { PObjectId } from "../../pool/spec.js";
-import "../../pool/index.js";
 import { PColumnIdAndSpec, PColumnSpec } from "./spec/spec.js";
 import { TableRange } from "./data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./find_columns.js";
 import { CalculateTableDataRequest, CalculateTableDataResponse } from "./table_calculate.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./unique_values.js";
+import { PObjectId } from "../../pool/spec.js";
+import "../../pool/index.js";
 
 //#region src/drivers/pframe/pframe.d.ts
 /** Read interface exposed by PFrames library */

package/dist/drivers/pframe/query/query_common.d.ts

@@ -1,8 +1,8 @@
-import { PObjectId } from "../../../pool/spec.js";
-import "../../../pool/index.js";
 import { AxisValueType, ColumnValueType } from "../spec/spec.js";
 import { JsonDataInfo } from "../data_info.js";
 import "../spec/index.js";
+import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 
 //#region src/drivers/pframe/query/query_common.d.ts
 /**

package/dist/drivers/pframe/query/query_data.d.ts

@@ -1,6 +1,6 @@
+import { ExprAxisRef, ExprColumnRef, ExprConstant, ExprIfNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, QueryAxisSelector, QueryColumn, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryOuterJoin, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySymmetricJoin, TypeSpec } from "./query_common.js";
 import { PObjectId } from "../../../pool/spec.js";
 import "../../../pool/index.js";
-import { ExprAxisRef, ExprColumnRef, ExprConstant, ExprIfNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, QueryAxisSelector, QueryColumn, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryOuterJoin, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySymmetricJoin, TypeSpec } from "./query_common.js";
 
 //#region src/drivers/pframe/query/query_data.d.ts
 /**

package/dist/drivers/pframe/query/query_spec.d.ts

@@ -1,9 +1,9 @@
-import { PObjectId } from "../../../pool/spec.js";
-import "../../../pool/index.js";
 import { Domain, PColumnIdAndSpec, PColumnSpec } from "../spec/spec.js";
 import { SingleAxisSelector } from "../spec/selectors.js";
 import "../spec/index.js";
 import { ExprAxisRef, ExprColumnRef, ExprConstant, ExprIfNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, QueryAxisSelector, QueryColumn, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryOuterJoin, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySymmetricJoin } from "./query_common.js";
+import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 
 //#region src/drivers/pframe/query/query_spec.d.ts
 /**