@milaboratories/pl-model-common 1.3.9 → 1.3.11

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/util.ts","../src/drivers/ls.ts","../src/drivers/pframe/data.ts","../src/drivers/pframe/spec.ts","../src/drivers/pframe/table_calculate.ts","../src/navigation.ts","../src/ref.ts","../src/pool/spec.ts","../src/pool/query.ts","../src/value_or_error.ts"],"names":["z","assertNever"],"mappings":";;;;;AAAO,SAAS,YAAY,CAAiB,EAAA;AAC3C,EAAM,MAAA,IAAI,KAAM,CAAA,qBAAA,GAAwB,CAAC,CAAA,CAAA;AAC3C,CAAA;;;ACAA,IAAM,YAAe,GAAA,kBAAA,CAAA;AACrB,IAAM,WAAc,GAAA,gBAAA,CAAA;AAOb,SAAS,yBACd,MACkC,EAAA;AAClC,EAAO,OAAA,MAAA,CAAO,WAAW,YAAY,CAAA,CAAA;AACvC,CAAA;AAEO,SAAS,wBACd,MACiC,EAAA;AACjC,EAAO,OAAA,MAAA,CAAO,WAAW,WAAW,CAAA,CAAA;AACtC,CAAA;AA+CO,SAAS,sBAAsB,MAAkC,EAAA;AACtE,EAAI,IAAA,uBAAA,CAAwB,MAAM,CAAG,EAAA;AACnC,IAAA,MAAM,OAAU,GAAA,MAAA,CAAO,KAAM,CAAA,WAAA,CAAY,MAAM,CAAA,CAAA;AAC/C,IAAA,MAAM,IAAO,GAAA,IAAA,CAAK,KAAM,CAAA,kBAAA,CAAmB,OAAO,CAAC,CAAA,CAAA;AACnD,IAAA,OAAO,IAAK,CAAA,IAAA,CAAA;AAAA,GACd,MAAA,IAAW,wBAAyB,CAAA,MAAM,CAAG,EAAA;AAC3C,IAAA,MAAM,OAAU,GAAA,MAAA,CAAO,KAAM,CAAA,YAAA,CAAa,MAAM,CAAA,CAAA;AAChD,IAAA,MAAM,IAAO,GAAA,IAAA,CAAK,KAAM,CAAA,kBAAA,CAAmB,OAAO,CAAC,CAAA,CAAA;AACnD,IAAA,OAAO,IAAK,CAAA,SAAA,CAAA;AAAA,GACd;AAEA,EAAA,WAAA,CAAY,MAAM,CAAA,CAAA;AACpB,CAAA;;;AC7EO,IAAM,WAAc,GAAA,CAAA,WAAA;AACpB,IAAM,eAAe,CAAC,kBAAA;AACtB,IAAM,aAAgB,GAAA,IAAA;AACtB,IAAM,cAAiB,GAAA,IAAA;AACvB,IAAM,cAAiB,GAAA,KAAA;AACvB,IAAM,aAAgB,GAAA,KAAA;;;AC8HtB,SAAS,UAAU,IAAwB,EAAA;AAChD,EAAO,OAAA,IAAA,CAAK,GAAI,CAAA,CAAC,CAAM,KAAA;AACrB,IAAA,MAAM,EAAE,IAAA,EAAM,IAAM,EAAA,MAAA,EAAW,GAAA,CAAA,CAAA;AAC/B,IAAO,OAAA,EAAE,IAAM,EAAA,IAAA,EAAM,MAAO,EAAA,CAAA;AAAA,GAC7B,CAAA,CAAA;AACH,CAAA;;;AC4HO,SAAS,YAAA,CACd,KACA,EACe,EAAA;AACf,EAAO,OAAA,EAAE,GAAG,GAAK,EAAA,GAAA,EAAK,aAAa,GAAI,CAAA,GAAA,EAAK,EAAE,CAAE,EAAA,CAAA;AAClD,CAAA;AAEO,SAAS,YAAA,CACd,OACA,EACe,EAAA;AACf,EAAA,QAAQ,MAAM,IAAM;AAAA,IAClB,KAAK,QAAA;AACH,MAAO,OAAA;AAAA,QACL,IAAM,EAAA,QAAA;AAAA,QACN,MAAA,EAAQ,EAAG,CAAA,KAAA,CAAM,MAAM,CAAA;AAAA,OACzB,CAAA;AAAA,IACF,KAAK,OAAA,CAAA;AAAA,IACL,KAAK,MAAA;AACH,MAAO,OAAA;AAAA,QACL,MAAM,KAAM,CAAA,IAAA;AAAA,QACZ,OAAA,EAAS,MAAM,OAAQ,CAAA,GAAA,CAAI,CAAC,GAAQ,KAAA,YAAA,CAAa,GAAK,EAAA,EAAE,CAAC,CAAA;AAAA,OAC3D,CAAA;AAAA,IACF,KAAK,OAAA;AACH,MAAO,OAAA;AAAA,QACL,IAAM,EAAA,OAAA;AAAA,QACN,OAAS,EAAA,YAAA,CAAa,KAAM,CAAA,OAAA,EAAS,EAAE,CAAA;AAAA,QACvC,SAAA,EAAW,MAAM,SAAU,CAAA,GAAA,CAAI,CAAC,GAAQ,KAAA,YAAA,CAAa,GAAK,EAAA,EAAE,CAAC,CAAA;AAAA,OAC/D,CAAA;AAAA,IACF;AACE,MAAA,WAAA,CAAY,KAAK,CAAA,CAAA;AAAA,GACrB;AACF,CAAA;;;ACxQa,IAAA,sBAAA,GAA0C,EAAE,IAAA,EAAM,GAAI,GAAA;AC5BtD,IAAA,GAAA,GAAMA,MAChB,MAAO,CAAA;AAAA,EACN,SAASA,KACN,CAAA,OAAA,CAAQ,IAAI,CAAA,CACZ,SAAS,6DAA6D,CAAA;AAAA,EACzE,OAAS,EAAAA,KAAA,CAAE,MAAO,EAAA,CAAE,SAAS,mBAAmB,CAAA;AAAA,EAChD,IAAA,EAAMA,KACH,CAAA,MAAA,EACA,CAAA,QAAA;AAAA,IACC,oEAAA;AAAA,GACF;AACJ,CAAC,CACA,CAAA,QAAA;AAAA,EACC,qMAAA;AAGF,CACC,CAAA,MAAA,GACA,QAAS,GAAA;;;ACWL,SAAS,cAAc,IAAwC,EAAA;AACpE,EAAA,OAAO,KAAK,IAAS,KAAA,SAAA,CAAA;AACvB,CAAA;AAEO,SAAS,UAAa,GAAoC,EAAA;AAC/D,EAAO,OAAA,aAAA,CAAc,IAAI,IAAI,CAAA,CAAA;AAC/B,CAAA;AAEO,SAAS,cAAiB,GAA6B,EAAA;AAC5D,EAAI,IAAA,CAAC,UAAU,GAAG,CAAA;AAChB,IAAA,MAAM,IAAI,KAAM,CAAA,CAAA,sBAAA,EAAyB,GAAI,CAAA,IAAA,CAAK,IAAI,CAAG,CAAA,CAAA,CAAA,CAAA;AAC3D,EAAO,OAAA,GAAA,CAAA;AACT,CAAA;AAUO,SAAS,cAAA,CACd,MACA,EACa,EAAA;AACb,EAAO,OAAA;AAAA,IACL,GAAG,IAAA;AAAA,IACH,IAAA,EAAM,EAAG,CAAA,IAAA,CAAK,IAAI,CAAA;AAAA,GACpB,CAAA;AACF,CAAA;;;AC1BA,SAASC,aAAY,CAAiB,EAAA;AACpC,EAAM,MAAA,IAAI,KAAM,CAAA,qBAAA,GAAwB,CAAC,CAAA,CAAA;AAC3C,CAAA;AAEO,SAAS,qBAAA,CACd,WACA,IACS,EAAA;AACT,EAAA,QAAQ,UAAU,IAAM;AAAA,IACtB,KAAK,KAAA;AACH,MAAA,KAAA,MAAW,YAAY,SAAU,CAAA,QAAA;AAC/B,QAAA,IAAI,CAAC,qBAAA,CAAsB,QAAU,EAAA,IAAI,GAAU,OAAA,KAAA,CAAA;AACrD,MAAO,OAAA,IAAA,CAAA;AAAA,IACT,KAAK,IAAA;AACH,MAAA,KAAA,MAAW,YAAY,SAAU,CAAA,QAAA;AAC/B,QAAA,IAAI,qBAAsB,CAAA,QAAA,EAAU,IAAI,CAAA,EAAU,OAAA,IAAA,CAAA;AACpD,MAAO,OAAA,KAAA,CAAA;AAAA,IACT,KAAK,KAAA;AACH,MAAA,OAAO,CAAC,qBAAA,CAAsB,SAAU,CAAA,OAAA,EAAS,IAAI,CAAA,CAAA;AAAA,IACvD,KAAK,MAAA;AACH,MAAA,OAAO,aAAc,CAAA,IAAI,CAAK,IAAA,IAAA,CAAK,SAAS,SAAU,CAAA,IAAA,CAAA;AAAA,IACxD,KAAK,cAAA;AACH,MAAO,OAAA,aAAA,CAAc,IAAI,CAAK,IAAA,OAAA,CAAQ,KAAK,IAAK,CAAA,KAAA,CAAM,SAAU,CAAA,OAAO,CAAC,CAAA,CAAA;AAAA,IAC1E,KAAK,YAAA;AACH,MACE,OAAA,aAAA,CAAc,IAAI,CAAA,IAClB,IAAK,CAAA,WAAA,KAAgB,KACrB,CAAA,IAAA,IAAA,CAAK,WAAY,CAAA,SAAA,CAAU,UAAU,CAAA,KAAM,SAAU,CAAA,KAAA,CAAA;AAAA,IAEzD,KAAK,oBAAA;AACH,MACE,OAAA,aAAA,CAAc,IAAI,CAClB,IAAA,IAAA,CAAK,gBAAgB,KACrB,CAAA,IAAA,IAAA,CAAK,YAAY,SAAU,CAAA,UAAU,MAAM,KAC3C,CAAA,IAAA,OAAA,CAAQ,KAAK,WAAY,CAAA,SAAA,CAAU,UAAU,CAAE,CAAA,KAAA,CAAM,SAAU,CAAA,OAAO,CAAC,CAAA,CAAA;AAAA,IAE3E,KAAK,UAAA;AACH,MAAA,OACE,aAAc,CAAA,IAAI,CAClB,IAAA,SAAA,CAAU,IAAK,CAAA,KAAA;AAAA,QAAM,CAAC,OACpB,KAAA,IAAA,CAAK,QAAS,CAAA,IAAA;AAAA,UACZ,CAAC,QAAA,KAAA,CACE,OAAQ,CAAA,IAAA,KAAS,UAAa,OAAQ,CAAA,IAAA,KAAS,QAAS,CAAA,IAAA,MACxD,OAAQ,CAAA,IAAA,KAAS,KAAa,CAAA,IAAA,OAAA,CAAQ,SAAS,QAAS,CAAA,IAAA,CAAA,KACxD,OAAQ,CAAA,MAAA,KAAW,KAClB,CAAA,IAAA,MAAA,CAAO,IAAK,CAAA,OAAA,CAAQ,MAAM,CAAE,CAAA,MAAA,KAAW,CACtC,IAAA,QAAA,CAAS,WAAW,KACnB,CAAA,IAAA,MAAA,CAAO,OAAQ,CAAA,OAAA,CAAQ,MAAM,CAAE,CAAA,KAAA;AAAA,YAC7B,CAAC,CAAC,MAAQ,EAAA,WAAW,MACnB,QAAS,CAAA,MAAA,CAAQ,MAAM,CAAM,KAAA,WAAA;AAAA,WACjC,CAAA;AAAA,SACR;AAAA,OACF,CAAA;AAAA,IAEJ;AACE,MAAAA,aAAY,SAAS,CAAA,CAAA;AAAA,GACzB;AACF,CAAA;;;AClFO,SAAS,aAAA,CACd,KACA,EACqB,EAAA;AACrB,EAAO,OAAA,GAAA,CAAI,EAAK,GAAA,EAAE,EAAI,EAAA,IAAA,EAAM,OAAO,EAAG,CAAA,GAAA,CAAI,KAAK,CAAA,EAAM,GAAA,GAAA,CAAA;AACvD","file":"index.cjs","sourcesContent":["export function assertNever(x: never): never {\n  throw new Error('Unexpected object: ' + x);\n}\n","import { assertNever } from '../util';\n\nconst uploadPrefix = 'upload://upload/';\nconst indexPrefix = 'index://index/';\n\nexport type ImportFileHandleUpload = `upload://upload/${string}`;\nexport type ImportFileHandleIndex = `index://index/${string}`;\n\nexport type ImportFileHandle = ImportFileHandleUpload | ImportFileHandleIndex;\n\nexport function isImportFileHandleUpload(\n  handle: ImportFileHandle\n): handle is ImportFileHandleUpload {\n  return handle.startsWith(uploadPrefix);\n}\n\nexport function isImportFileHandleIndex(\n  handle: ImportFileHandle\n): handle is ImportFileHandleIndex {\n  return handle.startsWith(indexPrefix);\n}\n\n/** Results in upload */\nexport type StorageHandleLocal = `local://${string}`;\n\n/** Results in index */\nexport type StorageHandleRemote = `remote://${string}`;\n\nexport type StorageHandle = StorageHandleLocal | StorageHandleRemote;\n\nexport type StorageEntry = {\n  name: string;\n  handle: StorageHandle;\n  initialFullPath: string;\n\n  // TODO\n  // pathStartsWithDisk\n};\n\nexport type ListFilesResult = {\n  parent?: string;\n  entries: LsEntry[];\n};\n\nexport type LsEntry =\n  | {\n      type: 'dir';\n      name: string;\n      fullPath: string;\n    }\n  | {\n      type: 'file';\n      name: string;\n      fullPath: string;\n\n      /** This handle should be set to args... */\n      handle: ImportFileHandle;\n    };\n\nexport interface LsDriver {\n  /** remote and local storages */\n  getStorageList(): Promise<StorageEntry[]>;\n\n  listFiles(storage: StorageHandle, fullPath: string): Promise<ListFilesResult>;\n}\n\n/** Gets a file path from an import handle. */\nexport function getFilePathFromHandle(handle: ImportFileHandle): string {\n  if (isImportFileHandleIndex(handle)) {\n    const trimmed = handle.slice(indexPrefix.length);\n    const data = JSON.parse(decodeURIComponent(trimmed));\n    return data.path;\n  } else if (isImportFileHandleUpload(handle)) {\n    const trimmed = handle.slice(uploadPrefix.length);\n    const data = JSON.parse(decodeURIComponent(trimmed));\n    return data.localPath;\n  }\n\n  assertNever(handle);\n}\n","import { ValueType } from './spec';\n\nexport const PValueIntNA = -2147483648;\nexport const PValueLongNA = -9007199254740991n;\nexport const PValueFloatNA = NaN;\nexport const PValueDoubleNA = NaN;\nexport const PValueStringNA = null;\nexport const PValueBytesNA = null;\n\nexport type PValueInt = number;\nexport type PValueLong = number; // use bigint only if extra integer precision is needed\nexport type PValueFloat = number;\nexport type PValueDouble = number;\nexport type PValueString = string | null;\nexport type PValueBytes = Uint8Array | null;\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = PValueString[];\nexport type PVectorDataBytes = PValueBytes[];\n\nexport type PVectorData =\n  | PVectorDataInt\n  | PVectorDataLong\n  | PVectorDataFloat\n  | PVectorDataDouble\n  | PVectorDataString\n  | PVectorDataBytes;\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 interface PTableVector {\n  /** Stored data type */\n  readonly type: ValueType;\n\n  /** Values for present positions, absent positions have NA values */\n  readonly data: PVectorData;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   *\n   * Encoding described here:\n   * https://gist.github.com/vadimpiven/45f8279d84f47b9857df845126694c39\n   * */\n  readonly absent: Uint8Array;\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","import { PObject, PObjectId, PObjectSpec } from '../../pool';\n\n/** PFrame columns and axes within them may store one of these types. */\nexport type ValueType =\n  | 'Int'\n  | 'Long'\n  | 'Float'\n  | 'Double'\n  | 'String'\n  | '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 PColumnSpec 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: 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  /** 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\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/** 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 axes ids from axes spec array from column spec */\nexport function getAxesId(spec: AxesSpec): AxesId {\n  return spec.map((s) => {\n    const { type, name, domain } = s;\n    return { type, name, domain };\n  });\n}\n","import { PTableColumnId, PTableColumnSpec } from './table_common';\nimport { PTableVector } from './data';\nimport { assertNever } from '../../util';\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 * 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  | 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 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 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 SingleValueNotPredicate {\n  /** Comparison operator */\n  readonly operator: 'Not';\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicate;\n}\n\nexport interface SingleValueAndPredicate {\n  /** Comparison operator */\n  readonly operator: 'And';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicate[];\n}\n\nexport interface SingleValueOrPredicate {\n  /** Comparison operator */\n  readonly operator: 'Or';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicate[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicate =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicate\n  | SingleValueAndPredicate\n  | SingleValueOrPredicate;\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 PTableRecordSingleValueFilter {\n  /** Filter type discriminator */\n  readonly type: 'bySingleColumn';\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicate;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilter;\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  /** 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> = PTableDef<Col>;\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 '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","/** Block section visualized as items in left panel block overview */\nexport type BlockSection = BlockSectionLink | BlockSectionDelimiter;\n\n/** Tells the system that specific section from the main UI of this block should\n * be opened */\nexport type BlockSectionLink = {\n  /** Potentially there may be multiple section types, i.e. for \"+\" rows and for\n   * sections directly opening html from the outputs. */\n  readonly type: 'link';\n\n  /** Internal block section identifier */\n  readonly href: `/${string}`;\n\n  /** Visible section title, can also be used in the window header. */\n  readonly label: string;\n};\n\n/** Create a horisontal line between sections */\nexport type BlockSectionDelimiter = {\n  readonly type: 'delimiter';\n};\n\n/**\n * Part of the block state, representing current navigation information\n * (i.e. currently selected section)\n * */\nexport type NavigationState<Href extends `/${string}` = `/${string}`> = {\n  readonly href: Href;\n};\n\nexport const DefaultNavigationState: NavigationState = { href: '/' };\n","import { z } from 'zod';\n\nexport const Ref = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe('Crucial marker for the block dependency tree reconstruction'),\n    blockId: z.string().describe('Upstream block id'),\n    name: z\n      .string()\n      .describe(\n        \"Name of the output provided to the upstream block's output context\"\n      )\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  .strict()\n  .readonly();\nexport type Ref = z.infer<typeof Ref>;\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: Ref;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n","import { Branded } from '../branding';\nimport { PColumn, PColumnSpec } from '../drivers';\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  /** 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 ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj))\n    throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1>,\n  cb: (d: D1) => D2\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1>,\n  cb: (d: D1) => D2\n): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1>,\n  cb: (d: D1) => D2\n): PObject<D2> {\n  return {\n    ...pObj,\n    data: cb(pObj.data)\n  };\n}\n","import { AxisId } from '../drivers';\nimport { PObjectSpec, isPColumnSpec } from './spec';\n\nexport type PSpecPredicate =\n  | {\n      type: 'and' | 'or';\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: 'not';\n      operand: PSpecPredicate;\n    }\n  | {\n      type: 'name';\n      name: string;\n    }\n  | {\n      type: 'name_pattern';\n      pattern: string;\n    }\n  | {\n      type: 'annotation';\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: 'annotation_pattern';\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: 'has_axes';\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error('Unexpected object: ' + x);\n}\n\nexport function executePSpecPredicate(\n  predicate: PSpecPredicate,\n  spec: PObjectSpec\n): boolean {\n  switch (predicate.type) {\n    case 'and':\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case 'or':\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case 'not':\n      return !executePSpecPredicate(predicate.operand, spec);\n    case 'name':\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case 'name_pattern':\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case 'annotation':\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case 'annotation_pattern':\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case 'has_axes':\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) =>\n                      axisSpec.domain![domain] === domainValue\n                  )))\n          )\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\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"]}