@milaboratories/graph-maker 1.1.132 → 1.1.133

package/dist/node_modules/@milaboratories/pl-model-common/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/blob.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/util.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/data_info.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/spec/spec.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/table_calculate.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/spec/ids.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/spec/anchored.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/pool/spec.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/spec/selectors.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/drivers/pframe/spec/native_id.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/ref.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/value_or_error.ts","../../../../../node_modules/@milaboratories/pl-model-common/src/plid.ts"],"sourcesContent":["import type { Branded } from '../branding';\nimport { z } from 'zod';\n\n/** Handle of locally downloaded blob. This handle is issued only after the\n * blob's content is downloaded locally, and ready for quick access. */\nexport type LocalBlobHandle = Branded<string, 'LocalBlobHandle'>;\n\n/** Handle of remote blob. This handle is issued as soon as the data becomes\n * available on the remote server. */\nexport type RemoteBlobHandle = Branded<string, 'RemoteBlobHandle'>;\n\n/** Being configured inside the output structure provides information about\n * blob's content and means to retrieve it when needed. */\nexport interface BlobHandleAndSize<\n  H extends LocalBlobHandle | RemoteBlobHandle = | LocalBlobHandle\n  | RemoteBlobHandle,\n> {\n  /** Handle to retrieve block content using {@link BlobDriver.getContent()} */\n  readonly handle: H;\n\n  /** Blob size in bytes. */\n  readonly size: number;\n}\n\n/** Range in bytes, from should be less or equal than to. */\nexport const RangeBytes = z.object({\n  /** Included left border. */\n  from: z.number(),\n  /** Excluded right border. */\n  to: z.number(),\n});\n\nexport type RangeBytes = z.infer<typeof RangeBytes>;\n\nexport function newRangeBytesOpt(from?: number, to?: number): RangeBytes | undefined {\n  if (from == undefined || to == undefined) {\n    return undefined;\n  }\n\n  return { from, to };\n}\n\nexport function validateRangeBytes(range: RangeBytes, errMsg: string) {\n  if (range.from < 0 || range.to < 0 || range.from >= range.to) {\n    throw new Error(`${errMsg}: invalid bytes range: ${range}`);\n  }\n}\n\n/** Being configured inside the output structure provides information about\n * locally downloaded blob and means to retrieve it's content when needed. This\n * structure is created only after the blob's content is downloaded locally, and\n * ready for quick access. */\nexport type LocalBlobHandleAndSize = BlobHandleAndSize<LocalBlobHandle>;\n\n/** Being configured inside the output structure provides information about\n * remote blob and means to retrieve it's content when needed. This structure\n * is created as soon as remote blob becomes available. */\nexport type RemoteBlobHandleAndSize = BlobHandleAndSize<RemoteBlobHandle>;\n\n/** Defines API of blob driver as it is seen from the block UI code. */\nexport interface BlobDriver {\n  /** Given the blob handle returns its content. Depending on the handle type,\n   * content will be served from locally downloaded file, or directly from\n   * remote platforma storage. */\n  getContent(handle: LocalBlobHandle | RemoteBlobHandle, range?: RangeBytes): Promise<Uint8Array>;\n}\n","export function assertNever(x: never): never {\n  throw new Error('Unexpected object: ' + x); // This is ok, because this is a possible runtime error\n}\n","/**\n * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.\n * These are the primitive types that can be stored directly in PColumns.\n *\n * Note: Actual columns can hold more value types, which are converted to these JavaScript types\n * once they enter the JavaScript runtime.\n */\nexport type PColumnValue = null | number | string;\n\n/**\n * Represents a key for a PColumn value.\n * Can be an array of strings or numbers.\n */\nexport type PColumnKey = (number | string)[];\n\n/**\n * Represents a single entry in a PColumn's data structure.\n * Contains a key and a value.\n */\nexport type PColumnDataEntry<T> = {\n  /** Key for the value */\n  key: PColumnKey;\n\n  /** Value / blob at the given key */\n  value: T;\n};\n\n/**\n * Represents column data stored as a simple JSON structure.\n * Used for small datasets that can be efficiently stored directly in memory.\n */\nexport type JsonDataInfo = {\n  /** Identifier for this data format ('Json') */\n  type: 'Json';\n\n  /** Number of axes that make up the complete key (tuple length) */\n  keyLength: number;\n\n  /**\n   * Key-value pairs where keys are stringified tuples of axis values\n   * and values are the column values for those coordinates\n   */\n  data: Record<string, PColumnValue>;\n};\n\n/**\n * Represents column data partitioned across multiple JSON blobs.\n * Used for larger datasets that need to be split into manageable chunks.\n */\nexport type JsonPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('JsonPartitioned') */\n  type: 'JsonPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to blob references */\n  parts: Record<string, Blob>;\n};\n\n/**\n * Represents a binary format chunk containing index and values as separate blobs.\n * Used for efficient storage and retrieval of column data in binary format.\n */\nexport type BinaryChunk<Blob> = {\n  /** Binary blob containing structured index information */\n  index: Blob;\n\n  /** Binary blob containing the actual values */\n  values: Blob;\n};\n\n/**\n * Represents column data partitioned across multiple binary chunks.\n * Optimized for efficient storage and retrieval of large datasets.\n */\nexport type BinaryPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('BinaryPartitioned') */\n  type: 'BinaryPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to binary chunks */\n  parts: Record<string, BinaryChunk<Blob>>;\n};\n\n/**\n * Union type representing all possible data storage formats for PColumn data.\n * The specific format used depends on data size, access patterns, and performance requirements.\n *\n * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)\n */\nexport type DataInfo<Blob> =\n  | JsonDataInfo\n  | JsonPartitionedDataInfo<Blob>\n  | BinaryPartitionedDataInfo<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfo.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfo, false otherwise\n */\nexport function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && data.data !== undefined\n        && typeof data.data === 'object'\n      );\n    case 'JsonPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && data.parts !== undefined\n        && typeof data.parts === 'object'\n      );\n    case 'BinaryPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && data.parts !== undefined\n        && typeof data.parts === 'object'\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Maps blob references in a DataInfo object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfo - The source DataInfo object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfo object with transformed blob references\n */\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2> | undefined {\n  if (dataInfo === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfo.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfo;\n    case 'JsonPartitioned': {\n      // Map each blob in parts\n      const newParts: Record<string, B2> = {};\n      for (const [key, blob] of Object.entries(dataInfo.parts)) {\n        newParts[key] = mapFn(blob);\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      // Map each index and values blob in parts\n      const newParts: Record<string, BinaryChunk<B2>> = {};\n      for (const [key, chunk] of Object.entries(dataInfo.parts)) {\n        newParts[key] = {\n          index: mapFn(chunk.index),\n          values: mapFn(chunk.values),\n        };\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n  }\n}\n\n//\n// Lightway representation for ExplicitJsonData\n//\n\n/**\n * Represents a single key-value entry in a column's explicit data structure.\n * Used when directly instantiating PColumns with explicit data.\n */\nexport type PColumnValuesEntry = {\n  key: PColumnKey;\n  val: PColumnValue;\n};\n\n/**\n * Array of key-value entries representing explicit column data.\n * Used for lightweight explicit instantiation of PColumns.\n */\nexport type PColumnValues = PColumnValuesEntry[];\n\n/**\n * Entry-based representation of JsonDataInfo\n */\nexport interface JsonDataInfoEntries {\n  type: 'Json';\n  keyLength: number;\n  data: PColumnDataEntry<PColumnValue>[];\n}\n\n/**\n * Entry-based representation of JsonPartitionedDataInfo\n */\nexport interface JsonPartitionedDataInfoEntries<Blob> {\n  type: 'JsonPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<Blob>[];\n}\n\n/**\n * Entry-based representation of BinaryPartitionedDataInfo\n */\nexport interface BinaryPartitionedDataInfoEntries<Blob> {\n  type: 'BinaryPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<BinaryChunk<Blob>>[];\n}\n\n/**\n * Union type representing all possible entry-based partitioned data storage formats\n */\nexport type PartitionedDataInfoEntries<Blob> =\n  | JsonPartitionedDataInfoEntries<Blob>\n  | BinaryPartitionedDataInfoEntries<Blob>;\n\n/**\n * Union type representing all possible entry-based data storage formats\n */\nexport type DataInfoEntries<Blob> =\n  | JsonDataInfoEntries\n  | PartitionedDataInfoEntries<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfoEntries.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfoEntries, false otherwise\n */\nexport function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && Array.isArray(data.data)\n      );\n    case 'JsonPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && Array.isArray(data.parts)\n      );\n    case 'BinaryPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && Array.isArray(data.parts)\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.\n *\n * @template Blob - Type parameter representing the storage reference type\n * @param value - The value to check\n * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise\n */\nexport function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob> {\n  if (!isDataInfoEntries(value)) return false;\n  return value.type === 'JsonPartitioned' || value.type === 'BinaryPartitioned';\n}\n\n/**\n * Converts DataInfo to DataInfoEntries\n *\n * @param dataInfo - The record-based DataInfo object\n * @returns The equivalent entry-based DataInfoEntries object\n */\nexport function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob> {\n  switch (dataInfo.type) {\n    case 'Json': {\n      const entries: PColumnDataEntry<PColumnValue>[] = Object.entries(dataInfo.data).map(([keyStr, value]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value };\n      });\n\n      return {\n        type: 'Json',\n        keyLength: dataInfo.keyLength,\n        data: entries,\n      };\n    }\n    case 'JsonPartitioned': {\n      const parts: PColumnDataEntry<Blob>[] = Object.entries(dataInfo.parts).map(([keyStr, blob]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: blob };\n      });\n\n      return {\n        type: 'JsonPartitioned',\n        partitionKeyLength: dataInfo.partitionKeyLength,\n        parts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      const parts: PColumnDataEntry<BinaryChunk<Blob>>[] = Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: chunk };\n      });\n\n      return {\n        type: 'BinaryPartitioned',\n        partitionKeyLength: dataInfo.partitionKeyLength,\n        parts,\n      };\n    }\n  }\n}\n\n/**\n * Converts DataInfoEntries to DataInfo\n *\n * @param dataInfoEntries - The entry-based DataInfoEntries object\n * @returns The equivalent record-based DataInfo object\n */\nexport function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob> {\n  switch (dataInfoEntries.type) {\n    case 'Json': {\n      const data: Record<string, PColumnValue> = {};\n      for (const entry of dataInfoEntries.data) {\n        data[JSON.stringify(entry.key)] = entry.value;\n      }\n\n      return {\n        type: 'Json',\n        keyLength: dataInfoEntries.keyLength,\n        data,\n      };\n    }\n    case 'JsonPartitioned': {\n      const parts: Record<string, Blob> = {};\n      for (const entry of dataInfoEntries.parts) {\n        parts[JSON.stringify(entry.key)] = entry.value;\n      }\n\n      return {\n        type: 'JsonPartitioned',\n        partitionKeyLength: dataInfoEntries.partitionKeyLength,\n        parts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      const parts: Record<string, BinaryChunk<Blob>> = {};\n      for (const entry of dataInfoEntries.parts) {\n        parts[JSON.stringify(entry.key)] = entry.value;\n      }\n\n      return {\n        type: 'BinaryPartitioned',\n        partitionKeyLength: dataInfoEntries.partitionKeyLength,\n        parts,\n      };\n    }\n  }\n}\n\n/**\n * Maps blob references in a DataInfoEntries object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfoEntries - The source DataInfoEntries object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfoEntries object with transformed blob references\n */\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2>;\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2> | undefined {\n  if (dataInfoEntries === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfoEntries.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfoEntries;\n    case 'JsonPartitioned': {\n      // Map each blob in parts\n      const newParts = dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: mapFn(entry.value),\n      }));\n\n      return {\n        ...dataInfoEntries,\n        parts: newParts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      // Map each index and values blob in parts\n      const newParts = dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: {\n          index: mapFn(entry.value.index),\n          values: mapFn(entry.value.values),\n        },\n      }));\n\n      return {\n        ...dataInfoEntries,\n        parts: newParts,\n      };\n    }\n  }\n}\n","import type { PObject, PObjectId, PObjectSpec } from '../../../pool';\nimport canonicalize from 'canonicalize';\n\n/** PFrame columns and axes within them may store one of these types. */\nexport type ValueType = 'Int' | 'Long' | 'Float' | 'Double' | 'String' | 'Bytes';\n\n/**\n * Specification of an individual axis.\n *\n * Each axis is a part of a composite key that addresses data inside the PColumn.\n *\n * Each record inside a PColumn is addressed by a unique tuple of values set for\n * all the axes specified in the column spec.\n * */\nexport interface AxisSpec {\n  /** Type of the axis value. Should not use non-key types like float or double. */\n  readonly type: ValueType;\n\n  /** Name of the axis */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** Any additional information attached to the axis that does not affect its\n   * identifier */\n  readonly annotations?: Record<string, string>;\n\n  /**\n   * Parent axes provide contextual grouping for the axis in question, establishing\n   * a hierarchy where the current axis is dependent on one or more axes for its\n   * full definition and meaning. For instance, in a data structure where each\n   * \"container\" axis may contain multiple \"item\" axes, the `item` axis would\n   * list the index of the `container` axis in this field to denote its dependency.\n   *\n   * This means that the identity or significance of the `item` axis is only\n   * interpretable when combined with its parent `container` axis. An `item` axis\n   * index by itself may be non-unique and only gains uniqueness within the context\n   * of its parent `container`. Therefore, the `parentAxes` field is essential for\n   * mapping these relationships and ensuring data coherence across nested or\n   * multi-level data models.\n   *\n   * A list of zero-based indices of parent axes in the overall axes specification\n   * from the column spec. Each index corresponds to the position of a parent axis\n   * in the list that defines the structure of the data model.\n   */\n  readonly parentAxes?: number[];\n}\n\n/** Common type representing spec for all the axes in a column */\nexport type AxesSpec = AxisSpec[];\n\n/**\n * Full column specification including all axes specs and specs of the column\n * itself.\n *\n * A PColumn in its essence represents a mapping from a fixed size, explicitly\n * typed tuple to an explicitly typed value.\n *\n * (axis1Value1, axis2Value1, ...) -> columnValue\n *\n * Each element in tuple correspond to the axis having the same index in axesSpec.\n * */\nexport interface PUniversalColumnSpec extends PObjectSpec {\n  /** Defines specific type of BObject, the most generic type of unit of\n   * information in Platforma Project. */\n  readonly kind: 'PColumn';\n\n  /** Type of column values */\n  readonly valueType: string;\n\n  /** Column name */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** Any additional information attached to the column that does not affect its\n   * identifier */\n  readonly annotations?: Record<string, string>;\n\n  /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */\n  readonly parentAxes?: number[];\n\n  /** Axes specifications */\n  readonly axesSpec: AxesSpec;\n}\n\n/**\n * Specification of a data column.\n *\n * Data column is a specialized type of PColumn that stores only simple values (strings and numbers)\n * addressed by multiple keys. This is in contrast to other PColumn variants that can store more complex\n * values like files or other abstract data types. Data columns are optimized for storing and processing\n * basic tabular data.\n */\nexport interface PDataColumnSpec extends PUniversalColumnSpec {\n  /** Type of column values */\n  readonly valueType: ValueType;\n}\n\n// @todo: change this to PUniversalColumnSpec\nexport type PColumnSpec = PDataColumnSpec;\n\n/** Unique PColumnSpec identifier */\nexport type PColumnSpecId = {\n  /** Defines specific type of BObject, the most generic type of unit of\n   * information in Platforma Project. */\n  readonly kind: 'PColumn';\n\n  /** Type of column values */\n  readonly valueType: ValueType;\n\n  /** Column name */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */\n  readonly parentAxes?: number[];\n\n  /** Axes id */\n  readonly axesId: AxesId;\n};\n\nexport function getPColumnSpecId(spec: PColumnSpec): PColumnSpecId {\n  return {\n    kind: spec.kind,\n    valueType: spec.valueType,\n    name: spec.name,\n    domain: spec.domain,\n    parentAxes: spec.parentAxes,\n    axesId: getAxesId(spec.axesSpec),\n  };\n}\n\nexport interface PColumn<Data> extends PObject<Data> {\n  /** PColumn spec, allowing it to be found among other PObjects */\n  readonly spec: PColumnSpec;\n}\n\n/** Columns in a PFrame also have internal identifier, this object represents\n * combination of specs and such id */\nexport interface PColumnIdAndSpec {\n  /** Internal column id within the PFrame */\n  readonly columnId: PObjectId;\n\n  /** Column spec */\n  readonly spec: PColumnSpec;\n}\n\n/** Get column id and spec from a column */\nexport function getColumnIdAndSpec<Data>(column: PColumn<Data>): PColumnIdAndSpec {\n  return {\n    columnId: column.id,\n    spec: column.spec,\n  };\n}\n\n/** Information returned by {@link PFrame.listColumns} method */\nexport interface PColumnInfo extends PColumnIdAndSpec {\n  /** True if data was associated with this PColumn */\n  readonly hasData: boolean;\n}\n\nexport interface AxisId {\n  /** Type of the axis or column value. For an axis should not use non-key\n   * types like float or double. */\n  readonly type: ValueType;\n\n  /** Name of the axis or column */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis or column name and type to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n}\n\n/** Array of axis ids */\nexport type AxesId = AxisId[];\n\n/** Extracts axis ids from axis spec */\nexport function getAxisId(spec: AxisSpec): AxisId {\n  const { type, name, domain } = spec;\n  const result = { type, name };\n  if (domain && Object.entries(domain).length > 0) {\n    Object.assign(result, { domain });\n  }\n  return result;\n}\n\n/** Extracts axes ids from axes spec array from column spec */\nexport function getAxesId(spec: AxesSpec): AxesId {\n  return spec.map(getAxisId);\n}\n\n/**\n * Canonicalizes axis id\n * @deprecated Use {@link canonicalizeJson} instead to preserve type\n */\nexport function canonicalizeAxisId(id: AxisId): string {\n  return canonicalize(getAxisId(id))!;\n}\n\n/** Returns true if all domains from query are found in target */\nfunction matchDomain(query?: Record<string, string>, target?: Record<string, string>) {\n  if (query === undefined) return target === undefined;\n  if (target === undefined) return true;\n  for (const k in target) {\n    if (query[k] !== target[k]) return false;\n  }\n  return true;\n}\n\n/** Returns whether \"match\" axis id is compatible with the \"query\" */\nexport function matchAxisId(query: AxisId, target: AxisId): boolean {\n  return query.name === target.name && matchDomain(query.domain, target.domain);\n}\n","import type { PTableColumnId, PTableColumnSpec } from './table_common';\nimport type { PTableVector } from './data_types';\nimport type { PObjectId } from '../../pool';\nimport { assertNever } from '../../util';\nimport type { PColumn } from './spec/spec';\nimport type { PColumnValues } from './data_info';\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: 'column';\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: 'constant';\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: 'slicedColumn';\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: 'inlineColumn';\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'inner';\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lacks corresponding combinations of axis values will be marked as absent,\n * see {@link PTableVector.absent}.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'full';\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lacks corresponding combinations of axis values\n * will be marked as absent, see {@link PTableVector.absent}.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'outer';\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: 'IsNA';\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'Equal';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: 'InSet';\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'IEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: 'Less';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'LessOrEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: 'Greater';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'GreaterOrEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: 'StringContains';\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'StringIContains';\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: 'Matches';\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: 'StringContainsFuzzy';\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'StringIContainsFuzzy';\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'Not';\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'And';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'Or';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: 'bySingleColumnV2';\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(\n  def: PTableDef<C1>,\n  cb: (c: C1) => C2,\n): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(\n  entry: JoinEntry<C1>,\n  cb: (c: C1) => C2,\n): JoinEntry<C2> {\n  switch (entry.type) {\n    case 'column':\n      return {\n        type: 'column',\n        column: cb(entry.column),\n      };\n    case 'slicedColumn':\n      return {\n        type: 'slicedColumn',\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case 'inlineColumn':\n      return entry;\n    case 'inner':\n    case 'full':\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case 'outer':\n      return {\n        type: 'outer',\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n","import type { Branded } from '../../../branding';\nimport type { AnchoredPColumnId } from './selectors';\nimport type { FilteredPColumnId } from './filtered_column';\nimport canonicalize from 'canonicalize';\nimport type { PObjectId } from '../../../pool';\n/**\n * Universal column identifier optionally anchored and optionally filtered.\n */\nexport type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId;\n\n/**\n * Canonically serialized {@link UniversalPColumnId}.\n */\nexport type SUniversalPColumnId = Branded<PObjectId, 'SUniversalPColumnId', '__pl_model_brand_2__'>;\n\n/**\n * Canonically serializes a {@link UniversalPColumnId} to a string.\n * @param id - The column identifier to serialize\n * @returns The canonically serialized string\n */\nexport function stringifyColumnId(id: UniversalPColumnId): SUniversalPColumnId {\n  return canonicalize(id)! as SUniversalPColumnId;\n}\n\n/**\n * Parses a canonically serialized {@link UniversalPColumnId} from a string.\n * @param str - The string to parse\n * @returns The parsed column identifier\n */\nexport function parseColumnId(str: SUniversalPColumnId): UniversalPColumnId {\n  return JSON.parse(str) as UniversalPColumnId;\n}\n","import canonicalize from 'canonicalize';\nimport type { PValue } from '../data_types';\nimport type { AxisFilter } from './filtered_column';\nimport type { SUniversalPColumnId, UniversalPColumnId } from './ids';\nimport { stringifyColumnId } from './ids';\nimport type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';\nimport type { AxisId, PColumnSpec } from './spec';\nimport { getAxisId, matchAxisId } from './spec';\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly domains = new Map<string, string>();\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(public readonly anchors: Record<string, PColumnSpec>) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer:\n      for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined)\n            dAnchor.push([domainKey, dValue]);\n          else\n            break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey))\n        continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, PValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === 'number') {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(`Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`);\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(`Axis with name \"${axisIdOrIndex}\" not found in the column specification`);\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n */\nexport function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec)\n      throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === 'string') {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.axes)\n    result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAxisSelector): AxisSelector {\n  if (!isAnchorAxisRef(axisRef))\n    return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec)\n    throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if ('idx' in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if ('name' in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if ('id' in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === 'object' && 'anchor' in value;\n}\n","import type { Branded } from '../branding';\nimport type { JoinEntry, PColumn, PColumnSpec } from '../drivers';\nimport { assertNever } from '../util';\nimport type { ResultPoolEntry } from './entry';\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport interface PObjectSpec {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n}\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, 'PColumnId'>;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === 'PColumn';\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case 'column':\n        columns.set(entry.column.id, entry.column);\n        return;\n      case 'slicedColumn':\n        columns.set(entry.column.id, entry.column);\n        return;\n      case 'inlineColumn':\n        return;\n      case 'full':\n      case 'inner':\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case 'outer':\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n","import { isPColumnSpec, type PObjectSpec } from '../../../pool';\nimport type { AxisId, PColumnSpec, ValueType } from './spec';\nimport { getAxisId } from './spec';\n\n/**\n * Defines a pattern for matching axes within the PFrame data model.\n *\n * AxisSelector provides a flexible way to identify axes based on their\n * properties. All fields are optional, allowing for partial matching.\n * When multiple properties are specified, all must match for an axis\n * to be selected (logical AND).\n *\n * This interface is used in various selection and matching operations\n * throughout the PFrame system, such as column queries and axis lookups.\n */\nexport interface AxisSelector {\n  /**\n   * Optional value type to match against.\n   * When specified, only axes with this exact type will match.\n   * Can be a single type or an array of types to match against any of them.\n   * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.\n   */\n  type?: ValueType | ValueType[];\n\n  /**\n   * Optional name to match against.\n   * When specified, only axes with this exact name will match.\n   */\n  name?: string;\n\n  /**\n   * Optional domain key-value pairs to match against.\n   * Domains provide additional context to uniquely identify an axis beyond its name and type.\n   * When specified, an axis will match only if it contains all the key-value pairs defined here.\n   * An axis with additional domain entries not present in this selector will still match.\n   */\n  domain?: Record<string, string>;\n}\n\n/**\n * Reference to an axis by its numerical index within the anchor column's axes array\n * Format: [anchorId, axisIndex]\n */\nexport type AnchorAxisRefByIdx = { anchor: string; idx: number };\n\n/**\n * Reference to an axis by its name within the anchor column\n * Format: [anchorId, axisName]\n */\nexport type AnchorAxisRefByName = { anchor: string; name: string };\n\n/**\n * Reference to an axis using an AxisId matcher within the anchor\n * Format: [anchorId, axisMatcher]\n */\nexport type AnchorAxisRefByMatcher = { anchor: string; id: AxisId };\n\n/**\n * Basic anchor axis reference that can be either by index or a direct AxisId\n */\nexport type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;\n\n/** Union of all possible ways to reference an axis in an anchored context  */\nexport type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;\n\n/** Reference to a domain value through an anchor */\nexport type AnchorDomainRef = { anchor: string };\n\n/**\n * Domain value that can be either a direct string value or a reference to a domain through an anchor\n * Used to establish domain context that can be resolved relative to other anchored columns\n */\nexport type ADomain = string | AnchorDomainRef;\n/**\n * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor\n * Allows referring to axes in a way that can be resolved in different contexts\n */\nexport type AAxisSelector = AxisSelector | AnchorAxisRef;\n\n/**\n * Match resolution strategy for PColumns\n * Specifies how to handle when multiple columns match the criteria\n * (default is \"expectSingle\")\n */\nexport type AnchoredColumnMatchStrategy = 'expectSingle' | 'expectMultiple' | 'takeFirst';\n\n/**\n * Matcher for PColumns in an anchored context\n * Supports partial matching on axes, allowing for flexible column discovery\n */\nexport interface AnchoredPColumnSelector {\n  /** Optional name of the column to match; can't be used together with namePattern */\n  name?: string;\n  /** Optional regexp pattern for column name matching; can't be used together with name */\n  namePattern?: string;\n  /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */\n  type?: ValueType | ValueType[];\n  /** If specified, the domain values must be anchored to this anchor */\n  domainAnchor?: string;\n  /** Optional domain values to match, can include anchored references, if domainAnchor is specified,\n   * interpreted as additional domains to domain from the anchor */\n  domain?: Record<string, ADomain>;\n  /** Optional axes to match, can include anchored references */\n  axes?: AAxisSelector[];\n  /** When true, allows matching if only a subset of axes match */\n  partialAxesMatch?: boolean;\n  /** Optional annotations to match with exact values */\n  annotations?: Record<string, string>;\n  /** Optional annotation patterns to match with regex patterns */\n  annotationPatterns?: Record<string, string>;\n  /** Match resolution strategy, default is \"expectSingle\" */\n  matchStrategy?: AnchoredColumnMatchStrategy;\n}\n\n/**\n * Matcher for PColumns in a non-anchored context\n */\nexport interface PColumnSelector extends AnchoredPColumnSelector {\n  domainAnchor?: never;\n  domain?: Record<string, string>;\n  axes?: AxisSelector[];\n}\n\n/**\n * Strict identifier for PColumns in an anchored context\n * Unlike APColumnMatcher, this requires exact matches on domain and axes\n */\nexport interface AnchoredPColumnId extends AnchoredPColumnSelector {\n  /** Name is required for exact column identification */\n  name: string;\n  /** No namePattern in ID */\n  namePattern?: never;\n  /** Type is not used in exact column identification */\n  type?: never;\n  /** Full axes specification using only basic references */\n  axes: AnchorAxisIdOrRefBasic[];\n  /** Partial axes matching is not allowed for exact identification */\n  partialAxesMatch?: never;\n  /** Annotations are not used in exact column identification */\n  annotations?: never;\n  /** Annotation patterns are not used in exact column identification */\n  annotationPatterns?: never;\n  /** \"Id\" implies single match strategy */\n  matchStrategy?: never;\n}\n\n/**\n * Determines if an axis ID matches an axis selector.\n *\n * @param selector - The selector with criteria to match against\n * @param axis - The AxisId to check against the selector\n * @returns true if the AxisId matches all specified criteria in the selector, false otherwise\n */\nexport function matchAxis(selector: AxisSelector, axis: AxisId): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && selector.name !== axis.name)\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(axis.type))\n        return false;\n    } else if (selector.type !== axis.type) {\n      return false;\n    }\n  }\n\n  // Match domain if specified - using existing logic from matchAxisId\n  if (selector.domain !== undefined) {\n    const axisDomain = axis.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (axisDomain[key] !== value)\n        return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a given PColumnSpec matches a selector.\n *\n * @param pcolumn - The PColumnSpec to check against the selector\n * @param selector - The selector criteria to match against\n * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise\n */\nexport function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && pcolumn.name !== selector.name)\n    return false;\n\n  // Match name pattern if specified\n  if (selector.namePattern !== undefined && !new RegExp(selector.namePattern).test(pcolumn.name))\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(pcolumn.valueType))\n        return false;\n    } else if (selector.type !== pcolumn.valueType) {\n      return false;\n    }\n  }\n\n  // Match domain if specified\n  if (selector.domain !== undefined) {\n    const columnDomain = pcolumn.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (columnDomain[key] !== value)\n        return false;\n  }\n\n  // Match axes if specified\n  if (selector.axes !== undefined) {\n    const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);\n\n    if (selector.partialAxesMatch) {\n      // For partial matching, all selector axes must match at least one column axis\n      for (const selectorAxis of selector.axes)\n        if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis)))\n          return false;\n    } else {\n      // For exact matching, column must have the same number of axes and all must match\n      if (pcolumnAxes.length !== selector.axes.length)\n        return false;\n\n      // Each selector axis must match a corresponding column axis\n      for (let i = 0; i < selector.axes.length; i++)\n        if (!matchAxis(selector.axes[i], pcolumnAxes[i]))\n          return false;\n    }\n  }\n\n  // Match annotations if specified\n  if (selector.annotations !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, value] of Object.entries(selector.annotations))\n      if (columnAnnotations[key] !== value)\n        return false;\n  }\n\n  // Match annotation patterns if specified\n  if (selector.annotationPatterns !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {\n      const value = columnAnnotations[key];\n      if (value === undefined || !new RegExp(pattern).test(value))\n        return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Convert a predicate or array of selectors to a single predicate function\n * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,\n *                              or an array of PColumnSelectors, or a single PColumnSelector\n * @returns A function that takes a PColumnSpec and returns a boolean\n */\nexport function selectorsToPredicate(predicateOrSelectors: PColumnSelector | PColumnSelector[]): ((spec: PObjectSpec) => boolean) {\n  if (Array.isArray(predicateOrSelectors))\n    return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));\n  else\n    return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);\n}\n","import type { Branded } from '../../../branding';\nimport { isPColumnSpec, type PObjectSpec } from '../../../pool';\nimport { getAxesId } from './spec';\nimport canonicalize from 'canonicalize';\nexport type NativePObjectId = Branded<string, 'NativePObjectId'>;\n\nexport function deriveNativeId(spec: PObjectSpec): NativePObjectId {\n  const result: Record<string, unknown> = {\n    kind: spec.kind,\n    name: spec.name,\n  };\n  if (spec.domain !== undefined)\n    result.domain = spec.domain;\n  if (isPColumnSpec(spec))\n    result.axesSpec = getAxesId(spec.axesSpec);\n  return canonicalize(result) as NativePObjectId;\n}\n","import { z } from 'zod';\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe('Crucial marker for the block dependency tree reconstruction'),\n    blockId: z.string()\n      .describe('Upstream block id'),\n    name: z.string()\n      .describe('Name of the output provided to the upstream block\\'s output context'),\n    requireEnrichments: z.literal(true).optional()\n      .describe('True if current block that stores this reference in its args, may need enrichments '\n        + 'for the references value originating from the blocks in between current and referenced block'),\n  })\n  .describe(\n    'Universal reference type, allowing to set block connections. It is crucial that '\n    + '{@link __isRef} is present and equal to true, internal logic relies on this marker '\n    + 'to build block dependency trees.',\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && '__isRef' in value\n    && (value as { __isRef: unknown }).__isRef === true\n    && 'blockId' in value\n    && 'name' in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(blockId: string, name: string, requireEnrichments: boolean = false) {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return ref1.blockId === ref2.blockId && ref1.name === ref2.name && (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments);\n}\n","export type ValueOrError<V, E> =\n  | {\n    ok: true;\n    value: V;\n  }\n  | {\n    ok: false;\n    error: E;\n  };\n\nexport function mapValueInVOE<V1, V2, E>(\n  voe: ValueOrError<V1, E>,\n  cb: (value: V1) => V2,\n): ValueOrError<V2, E> {\n  return voe.ok ? { ok: true, value: cb(voe.value) } : voe;\n}\n","import { z } from 'zod';\nimport { base32Encode } from './base32_encode';\n\n/** Number of raw bytes in the PlId. */\nexport const PlIdBytes = 15;\n/** Characters in string representation */\nexport const PlIdLength = 24; // = 15 bytes * 8 bits / 5 bits per char in base32\n\nexport const PlId = z\n  .string()\n  .length(PlIdLength)\n  .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/) // RFC4648\n  .brand('PlId');\nexport type PlId = z.infer<typeof PlId>;\n\nexport function uniquePlId(): PlId {\n  const data = new Uint8Array(PlIdBytes);\n  crypto.getRandomValues(data);\n  return PlId.parse(base32Encode(data, 'RFC4648'));\n}\n\nexport function plId(bytes: Uint8Array): PlId {\n  if (bytes.length !== PlIdBytes) throw new Error(`Wrong number of bytes: ${bytes.length}`);\n  return PlId.parse(base32Encode(bytes, 'RFC4648'));\n}\n\nexport async function digestPlId(data: string): Promise<PlId> {\n  const encoder = new TextEncoder();\n  const bytes = await crypto.subtle.digest('SHA-256', encoder.encode(data));\n  return plId(new Uint8Array(bytes.slice(0, 15)));\n}\n"],"names":["z","assertNever","x","isDataInfo","value","data","mapDataInfo","dataInfo","mapFn","newParts","key","blob","chunk","isDataInfoEntries","isPartitionedDataInfoEntries","dataInfoToEntries","entries","keyStr","parts","entriesToDataInfo","dataInfoEntries","entry","getAxisId","spec","type","name","domain","result","getAxesId","canonicalizeAxisId","id","canonicalize","matchDomain","query","target","k","matchAxisId","mapPTableDef","def","cb","mapJoinEntry","col","stringifyColumnId","axisKey","axis","domainKey","AnchoredIdDeriver","anchors","__publicField","anchorEntries","a","b","anchorId","axisIdx","domainEntries","dKey","dValue","axisFilters","skipDomains","outer","domainPack","dAnchor","domainAnchor","anchorAxisRef","resolvedFilters","filter","axisIdOrIndex","axisIndex","resolveAnchors","matcher","options","ignoreMissingDomains","anchorSpec","anchorDomains","resolvedDomain","resolveAxisReference","axisRef","isAnchorAxisRef","matches","isPColumnSpec","isPColumn","obj","ensurePColumn","mapPObjectData","pObj","extractAllColumns","columns","addAllColumns","e","matchAxis","selector","axisDomain","matchPColumn","pcolumn","columnDomain","pcolumnAxes","selectorAxis","columnAxis","i","columnAnnotations","pattern","selectorsToPredicate","predicateOrSelectors","deriveNativeId","isPlRef","withEnrichments","ref","requireEnrichments","_","rest","mapValueInVOE","voe","PlIdLength"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12]}