{"version":3,"file":"column_collection.cjs","names":["legacyColumnSelectorsToPredicate","canonicalizeAxisId","resolveAnchors","deriveNativeId","isPColumnSpec","convertOrParsePColumnData","isPartitionedDataInfoEntries","getUniquePartitionKeys","getAxisId","deriveLabels","Annotation","entriesToDataInfo","filterDataInfoEntries","isLinkerColumn","LinkerMap","getColumnIdAndSpec","matchAxisId"],"sources":["../../../src/render/util/column_collection.ts"],"sourcesContent":["import type {\n  AnchoredIdDeriver,\n  AnchoredPColumnSelector,\n  AxisFilterByIdx,\n  AxisFilterValue,\n  AxisId,\n  NativePObjectId,\n  PartitionedDataInfoEntries,\n  PColumn,\n  PColumnSelector,\n  PColumnSpec,\n  PColumnValues,\n  PObjectId,\n  ResolveAnchorsOptions,\n  SUniversalPColumnId,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  Annotation,\n  canonicalizeAxisId,\n  deriveNativeId,\n  entriesToDataInfo,\n  getAxisId,\n  getColumnIdAndSpec,\n  isLinkerColumn,\n  isPartitionedDataInfoEntries,\n  isPColumnSpec,\n  legacyColumnSelectorsToPredicate,\n  LinkerMap,\n  matchAxisId,\n  resolveAnchors,\n} from \"@milaboratories/pl-model-common\";\nimport canonicalize from \"canonicalize\";\nimport type { Optional } from \"utility-types\";\nimport type { TreeNodeAccessor } from \"../accessor\";\nimport type { PColumnDataUniversal } from \"../internal\";\nimport { filterDataInfoEntries } from \"./axis_filtering\";\nimport type { LabelDerivationOps } from \"./label\";\nimport { deriveLabels } from \"./label\";\nimport { convertOrParsePColumnData, getUniquePartitionKeys } from \"./pcolumn_data\";\nimport type { APColumnSelectorWithSplit, PColumnSelectorWithSplit } from \"./split_selectors\";\n\nfunction isPColumnValues(value: unknown): value is PColumnValues {\n  if (!Array.isArray(value)) return false;\n  if (value.length === 0) return true;\n  const first = value[0];\n  return typeof first === \"object\" && first !== null && \"key\" in first && \"val\" in first;\n}\n\nexport interface ColumnProvider {\n  selectColumns(\n    selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[],\n  ): PColumn<PColumnDataUniversal | undefined>[];\n}\n\nexport interface AxisLabelProvider {\n  findLabels(axis: AxisId): Record<string | number, string> | undefined;\n}\n\n/**\n * A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.\n */\nclass ArrayColumnsProvider implements ColumnProvider {\n  constructor(private readonly columns: PColumn<PColumnDataUniversal | undefined>[]) {}\n\n  selectColumns(\n    selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[],\n  ): PColumn<PColumnDataUniversal | undefined>[] {\n    const predicate =\n      typeof selectors === \"function\" ? selectors : legacyColumnSelectorsToPredicate(selectors);\n    // Filter based on spec, ignoring data type for now\n    return this.columns.filter((column): column is PColumn<PColumnDataUniversal | undefined> =>\n      predicate(column.spec),\n    );\n  }\n}\n\n/** Lazy calculates the data, returns undefined if data is not ready. */\nexport type PColumnWithLabel<T> = PColumn<T> & {\n  label: string;\n};\n\n/** Universal column is a column that uses a universal column id, and always have label. */\nexport type PColumnUniversal<T> = PColumnWithLabel<T> & {\n  id: SUniversalPColumnId;\n};\n\n/** @deprecated Use PColumnWithLabel instead. */\nexport type PColumnEntryWithLabel = PColumn<undefined | PColumnDataUniversal> & {\n  label: string;\n};\n\n/** @deprecated Use PColumnUniversal instead. */\nexport type PColumnEntryUniversal = PColumnEntryWithLabel & {\n  id: SUniversalPColumnId;\n};\n\n// Helper types similar to those in api.ts\ntype AxisFilterInfo = {\n  axisIdx: number;\n  axisId: AxisId;\n  value: AxisFilterValue;\n  label: string;\n};\n\n// Intermediate representation for columns requiring splitting\ntype IntermediateSplitEntry = {\n  type: \"split\";\n  originalColumn: PColumn<PColumnDataUniversal | undefined>;\n  spec: PColumnSpec;\n  /** With splitting axes removed */\n  adjustedSpec: PColumnSpec;\n  dataEntries: PartitionedDataInfoEntries<TreeNodeAccessor>;\n  axisFilters: AxisFilterInfo[];\n};\n\n// Intermediate representation for columns NOT requiring splitting\ntype IntermediateDirectEntry = {\n  type: \"direct\";\n  originalColumn: PColumn<PColumnDataUniversal | undefined>;\n  spec: PColumnSpec;\n  /** The same as `spec` */\n  adjustedSpec: PColumnSpec;\n};\n\n// Union type for intermediate processing\ntype IntermediateColumnEntry = IntermediateSplitEntry | IntermediateDirectEntry;\n\nfunction splitFiltersToExtraTrace(splitFilters?: AxisFilterInfo[]) {\n  if (splitFilters === undefined) return undefined;\n  return splitFilters.map((filter) => ({\n    type: `split:${canonicalizeAxisId(filter.axisId)}`,\n    label: filter.label,\n    importance: 1_000_000, // High importance for split filters in labels\n  }));\n}\n\nfunction splitFiltersToAxisFilter(splitFilters?: AxisFilterInfo[]): AxisFilterByIdx[] | undefined {\n  if (!splitFilters) return undefined;\n  return splitFilters.map((filter): AxisFilterByIdx => [filter.axisIdx, filter.value]);\n}\n\nfunction fallbackIdDeriver(originalId: PObjectId, axisFilters?: AxisFilterByIdx[]): PObjectId {\n  if (!axisFilters || axisFilters.length === 0) return originalId;\n  const filtersToCanonicalize = [...axisFilters].sort((a, b) => a[0] - b[0]);\n  return canonicalize({ id: originalId, axisFilters: filtersToCanonicalize })! as PObjectId;\n}\n\n/** Checks if a selector object uses any anchor properties */\nfunction hasAnchors(selector: unknown): selector is AnchoredPColumnSelector {\n  if (!selector || typeof selector !== \"object\") return false;\n  const potentialAnchored = selector as Record<string, any>;\n  const hasAnchorValues = (obj: unknown) =>\n    obj &&\n    typeof obj === \"object\" &&\n    Object.values(obj).some((v: unknown) => typeof v === \"object\" && v !== null && \"anchor\" in v);\n  const domainHasAnchors = hasAnchorValues(potentialAnchored[\"domain\"]);\n  const contextDomainHasAnchors = hasAnchorValues(potentialAnchored[\"contextDomain\"]);\n  const axesHaveAnchors =\n    potentialAnchored[\"axes\"] &&\n    Array.isArray(potentialAnchored[\"axes\"]) &&\n    potentialAnchored[\"axes\"].some(\n      (a: unknown) => typeof a === \"object\" && a !== null && \"anchor\" in a,\n    );\n  return (\n    !!potentialAnchored[\"domainAnchor\"] ||\n    !!potentialAnchored[\"contextDomainAnchor\"] ||\n    domainHasAnchors ||\n    contextDomainHasAnchors ||\n    axesHaveAnchors\n  );\n}\n\n/**\n * Derives the indices of axes marked for splitting based on the selector.\n * Throws an error if splitting is requested alongside `partialAxesMatch`.\n */\nfunction getSplitAxisIndices(\n  selector: APColumnSelectorWithSplit | ((spec: PColumnSpec) => boolean),\n): number[] {\n  if (typeof selector !== \"object\" || !(\"axes\" in selector) || selector.axes === undefined) {\n    return []; // No axes specified or not an object selector, no splitting\n  }\n\n  const splitIndices = selector.axes\n    .map((axis, index) =>\n      typeof axis === \"object\" && \"split\" in axis && axis.split === true ? index : -1,\n    )\n    .filter((index) => index !== -1);\n\n  if (splitIndices.length > 0 && selector.partialAxesMatch !== undefined) {\n    throw new Error(\"Axis splitting is not supported when `partialAxesMatch` is defined.\");\n  }\n\n  splitIndices.sort((a, b) => a - b);\n  return splitIndices;\n}\n\ntype UniversalPColumnOptsNoDeriver = {\n  /** If provided, columns matching the provided selectors will be excluded from the result. */\n  exclude?: AnchoredPColumnSelector | AnchoredPColumnSelector[];\n  labelOps?: LabelDerivationOps;\n  /** If true, incomplete data will cause the column to be skipped instead of returning undefined for the whole request. */\n  dontWaitAllData?: boolean;\n  /**\n   * If true, the derived label will override the 'pl7.app/label' annotation\n   * in the resulting PColumnSpec. It also forces `includeNativeLabel` in `labelOps` to true,\n   * unless `labelOps.includeNativeLabel` is explicitly set to false.\n   * Default value in getUniversalEntries is false, in getColumns it is true.\n   */\n  overrideLabelAnnotation?: boolean;\n  /** If true, resulting columns will be enriched by other columns considering linker columns. Default is false. */\n  enrichByLinkers?: boolean;\n};\n\ntype UniversalPColumnOpts = UniversalPColumnOptsNoDeriver & {\n  anchorCtx: AnchoredIdDeriver;\n} & ResolveAnchorsOptions;\n\nexport class PColumnCollection {\n  private readonly defaultProviderStore: PColumn<PColumnDataUniversal | undefined>[] = [];\n  private readonly providers: ColumnProvider[] = [\n    new ArrayColumnsProvider(this.defaultProviderStore),\n  ];\n  private readonly axisLabelProviders: AxisLabelProvider[] = [];\n\n  constructor() {}\n\n  public addColumnProvider(provider: ColumnProvider): this {\n    this.providers.push(provider);\n    return this;\n  }\n\n  public addAxisLabelProvider(provider: AxisLabelProvider): this {\n    this.axisLabelProviders.push(provider);\n    return this;\n  }\n\n  public addColumns(columns: PColumn<PColumnDataUniversal | undefined>[]): this {\n    this.defaultProviderStore.push(...columns);\n    return this;\n  }\n\n  public addColumn(column: PColumn<PColumnDataUniversal | undefined>): this {\n    this.defaultProviderStore.push(column);\n    return this;\n  }\n\n  /** Fetches labels for a given axis from the registered providers */\n  private findLabels(axis: AxisId): Record<string | number, string> | undefined {\n    for (const provider of this.axisLabelProviders) {\n      const labels = provider.findLabels(axis);\n      if (labels) return labels; // First provider wins\n    }\n    return undefined;\n  }\n\n  // Overload signatures updated to return PColumnEntry types\n  public getUniversalEntries(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts: UniversalPColumnOpts,\n  ): PColumnEntryUniversal[] | undefined;\n  public getUniversalEntries(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | PColumnSelectorWithSplit\n      | PColumnSelectorWithSplit[],\n    opts?: UniversalPColumnOptsNoDeriver,\n  ): PColumnEntryWithLabel[] | undefined;\n  public getUniversalEntries(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts?: Optional<UniversalPColumnOpts, \"anchorCtx\">,\n  ): (PColumnEntryWithLabel | PColumnEntryUniversal)[] | undefined {\n    const {\n      anchorCtx,\n      labelOps: rawLabelOps,\n      dontWaitAllData = false,\n      overrideLabelAnnotation = false,\n      exclude,\n      enrichByLinkers = false,\n    } = opts ?? {};\n\n    const labelOps: LabelDerivationOps = {\n      ...(overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false\n        ? { includeNativeLabel: true }\n        : {}),\n      ...rawLabelOps,\n    };\n\n    let excludePredicate: (spec: PColumnSpec) => boolean = () => false;\n    if (exclude) {\n      const excludePredicartes = (Array.isArray(exclude) ? exclude : [exclude]).map((selector) => {\n        if (hasAnchors(selector)) {\n          if (!anchorCtx)\n            throw new Error(\n              \"Anchored selectors in exclude require an AnchoredIdDeriver to be provided in options.\",\n            );\n          return legacyColumnSelectorsToPredicate(\n            resolveAnchors(anchorCtx.anchors, selector, opts),\n          );\n        } else return legacyColumnSelectorsToPredicate(selector);\n      });\n      excludePredicate = (spec) => excludePredicartes.some((predicate) => predicate(spec));\n    }\n\n    const selectorsArray =\n      typeof predicateOrSelectors === \"function\"\n        ? [predicateOrSelectors]\n        : Array.isArray(predicateOrSelectors)\n          ? predicateOrSelectors\n          : [predicateOrSelectors];\n\n    const intermediateResults: IntermediateColumnEntry[] = [];\n    const selectedNativeIds = new Set<NativePObjectId>();\n\n    for (const rawSelector of selectorsArray) {\n      const usesAnchors = hasAnchors(rawSelector);\n\n      let currentSelector: PColumnSelectorWithSplit | ((spec: PColumnSpec) => boolean);\n      if (usesAnchors) {\n        if (!anchorCtx)\n          throw new Error(\n            \"Anchored selectors require an AnchoredIdDeriver to be provided in options.\",\n          );\n        currentSelector = resolveAnchors(\n          anchorCtx.anchors,\n          rawSelector as AnchoredPColumnSelector,\n          opts,\n        );\n      } else\n        currentSelector = rawSelector as\n          | PColumnSelectorWithSplit\n          | ((spec: PColumnSpec) => boolean);\n\n      const selectedIds = new Set<PObjectId>();\n      const selectedColumns: PColumn<PColumnDataUniversal | undefined>[] = [];\n      for (const provider of this.providers) {\n        const providerColumns = provider.selectColumns(currentSelector);\n        const providerIds = new Set<PObjectId>();\n        for (const col of providerColumns) {\n          if (excludePredicate(col.spec)) continue;\n          if (providerIds.has(col.id))\n            throw new Error(\n              `Duplicate column id ${col.id} in provider ${provider.constructor.name}`,\n            );\n          providerIds.add(col.id);\n          // The same column offered by several providers is taken once, from the first of them.\n          const nativeId = deriveNativeId(col.spec);\n          if (selectedNativeIds.has(nativeId)) continue;\n          if (selectedIds.has(col.id))\n            throw new Error(\n              `Column id ${col.id} in provider ${provider.constructor.name} is already taken by a different column of another provider`,\n            );\n          selectedIds.add(col.id);\n          selectedNativeIds.add(nativeId);\n          selectedColumns.push(col);\n        }\n      }\n\n      if (selectedColumns.length === 0) continue;\n\n      const splitAxisIdxs = getSplitAxisIndices(rawSelector);\n      const needsSplitting = splitAxisIdxs.length > 0;\n\n      for (const column of selectedColumns) {\n        if (!isPColumnSpec(column.spec)) continue;\n\n        const originalSpec = column.spec;\n\n        if (needsSplitting) {\n          if (isPColumnValues(column.data))\n            throw new Error(\n              `Splitting is not supported for PColumns with PColumnValues data format. Column id: ${column.id}`,\n            );\n          const dataEntries = convertOrParsePColumnData(column.data);\n\n          if (!dataEntries) {\n            if (dontWaitAllData) continue;\n            return undefined;\n          }\n\n          if (!isPartitionedDataInfoEntries(dataEntries))\n            throw new Error(\n              `Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${dataEntries.type} for column ${column.id}`,\n            );\n\n          const uniqueKeys = getUniquePartitionKeys(dataEntries);\n\n          const maxSplitIdx = splitAxisIdxs[splitAxisIdxs.length - 1];\n          if (maxSplitIdx >= dataEntries.partitionKeyLength)\n            throw new Error(\n              `Not enough partition keys (${dataEntries.partitionKeyLength}) for requested split axes (max index ${maxSplitIdx}) in column ${originalSpec.name}`,\n            );\n\n          const axesLabels: (Record<string | number, string> | undefined)[] = splitAxisIdxs.map(\n            (idx) => this.findLabels(getAxisId(originalSpec.axesSpec[idx])),\n          );\n\n          const keyCombinations: (string | number)[][] = [];\n          const generateCombinations = (currentCombo: (string | number)[], sAxisIdx: number) => {\n            if (sAxisIdx >= splitAxisIdxs.length) {\n              keyCombinations.push([...currentCombo]);\n              if (keyCombinations.length > 10000)\n                throw new Error(\"Too many key combinations, aborting.\");\n              return;\n            }\n            const axisIdx = splitAxisIdxs[sAxisIdx];\n            if (axisIdx >= uniqueKeys.length)\n              throw new Error(\n                `Axis index ${axisIdx} out of bounds for unique keys array (length ${uniqueKeys.length}) during split key generation for column ${column.id}`,\n              );\n            const axisValues = uniqueKeys[axisIdx];\n            if (!axisValues || axisValues.length === 0) {\n              keyCombinations.length = 0; // No combinations possible if one axis has no keys\n              return;\n            }\n            for (const val of axisValues) {\n              currentCombo.push(val);\n              generateCombinations(currentCombo, sAxisIdx + 1);\n              currentCombo.pop();\n            }\n          };\n\n          generateCombinations([], 0);\n\n          if (keyCombinations.length === 0) continue;\n\n          const newAxesSpec = [...originalSpec.axesSpec];\n          const splitAxisOriginalIdxs = splitAxisIdxs.map((idx) => idx); // Keep original indices for axisId lookup\n          // Remove axes in reverse order to maintain correct indices during removal\n          for (let i = splitAxisIdxs.length - 1; i >= 0; i--) {\n            newAxesSpec.splice(splitAxisIdxs[i], 1);\n          }\n          const adjustedSpec = { ...originalSpec, axesSpec: newAxesSpec };\n\n          for (const keyCombo of keyCombinations) {\n            const splitFilters: AxisFilterInfo[] = keyCombo.map((value, sAxisIdx) => {\n              const axisIdx = splitAxisOriginalIdxs[sAxisIdx]; // Use original index for lookup\n              const axisId = getAxisId(originalSpec.axesSpec[axisIdx]);\n              const axisLabelMap = axesLabels[sAxisIdx];\n              const label = axisLabelMap?.[value] ?? String(value);\n              return { axisIdx, axisId, value: value as AxisFilterValue, label };\n            });\n\n            intermediateResults.push({\n              type: \"split\",\n              originalColumn: column,\n              spec: originalSpec,\n              adjustedSpec,\n              dataEntries,\n              axisFilters: splitFilters,\n            });\n          }\n        } else {\n          intermediateResults.push({\n            type: \"direct\",\n            originalColumn: column,\n            spec: originalSpec,\n            adjustedSpec: originalSpec,\n          });\n        }\n      }\n    }\n\n    if (intermediateResults.length === 0) return [];\n\n    const labeledResults = deriveLabels(\n      intermediateResults,\n      (entry) => ({\n        spec: entry.spec,\n        extraTrace:\n          entry.type === \"split\" ? splitFiltersToExtraTrace(entry.axisFilters) : undefined,\n      }),\n      labelOps,\n    );\n\n    const result: (PColumnEntryWithLabel | PColumnEntryUniversal)[] = [];\n\n    for (const { value: entry, label } of labeledResults) {\n      const { originalColumn, spec: originalSpec } = entry;\n\n      const axisFilters = entry.type === \"split\" ? entry.axisFilters : undefined;\n      const axisFiltersTuple = splitFiltersToAxisFilter(axisFilters);\n\n      let finalId: SUniversalPColumnId | PObjectId;\n      if (anchorCtx) finalId = anchorCtx.deriveS(originalSpec, axisFiltersTuple);\n      else finalId = fallbackIdDeriver(originalColumn.id, axisFiltersTuple);\n\n      let finalSpec = { ...entry.adjustedSpec };\n\n      if (overrideLabelAnnotation) {\n        finalSpec = {\n          ...finalSpec,\n          annotations: {\n            ...finalSpec.annotations,\n            [Annotation.Label]: label,\n          } satisfies Annotation,\n        };\n      }\n\n      result.push({\n        id: finalId as PObjectId,\n        spec: finalSpec,\n        get data() {\n          return entry.type === \"split\"\n            ? entriesToDataInfo(filterDataInfoEntries(entry.dataEntries, axisFiltersTuple!))\n            : entry.originalColumn.data;\n        },\n        label: label,\n      });\n    }\n\n    const ids = new Set(result.map((entry) => entry.id));\n\n    if (enrichByLinkers && anchorCtx) {\n      const linkers = result.filter((entry) => isLinkerColumn(entry.spec));\n      if (linkers.length === 0) {\n        return result;\n      }\n\n      const anchorAxes = Object.values(anchorCtx.anchors).flatMap((anchor) => anchor.axesSpec);\n      const linkerMap = LinkerMap.fromColumns(linkers.map(getColumnIdAndSpec));\n\n      // loose way of matching\n      function matchAxisIdFn(linkerKeyId: AxisId, sourceAxisId: AxisId): boolean {\n        return matchAxisId(linkerKeyId, sourceAxisId) || matchAxisId(sourceAxisId, linkerKeyId);\n      }\n      // search all axes that can be reached by linkers from anchor axes; anchor axes are not in this list;\n      const availableByLinkersAxes = linkerMap.getReachableByLinkersAxesFromAxes(\n        anchorAxes,\n        matchAxisIdFn,\n      );\n\n      // search all columns that includes at least one of additional axes;\n      const availableByLinkersColumns = this.getUniversalEntries(\n        (spec) =>\n          !isLinkerColumn(spec) &&\n          spec.axesSpec.some((columnAxisSpec) => {\n            const columnAxisId = getAxisId(columnAxisSpec);\n            return availableByLinkersAxes.some((axis) =>\n              matchAxisIdFn(getAxisId(axis), columnAxisId),\n            );\n          }),\n        { anchorCtx, labelOps, dontWaitAllData, overrideLabelAnnotation, exclude },\n      );\n      if (availableByLinkersColumns) {\n        result.push(...availableByLinkersColumns.filter((entry) => !ids.has(entry.id)));\n      }\n    }\n\n    return result;\n  }\n\n  public getColumns(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts: UniversalPColumnOpts,\n  ): PColumn<undefined | PColumnDataUniversal>[] | undefined;\n  public getColumns(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | PColumnSelectorWithSplit\n      | PColumnSelectorWithSplit[],\n    opts?: UniversalPColumnOptsNoDeriver,\n  ): PColumn<undefined | PColumnDataUniversal>[] | undefined;\n  public getColumns(\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts?: Optional<UniversalPColumnOpts, \"anchorCtx\">,\n  ): PColumn<undefined | PColumnDataUniversal>[] | undefined {\n    const entries = this.getUniversalEntries(predicateOrSelectors, {\n      overrideLabelAnnotation: true, // default for getColumns\n      ...opts,\n    } as UniversalPColumnOpts);\n    if (!entries) return undefined;\n\n    const columns: PColumn<undefined | PColumnDataUniversal>[] = [];\n    for (const entry of entries) {\n      const data = entry.data;\n      if (!data) {\n        if (opts?.dontWaitAllData) continue;\n        return undefined;\n      }\n      columns.push({\n        id: entry.id,\n        spec: entry.spec,\n        data,\n      });\n    }\n\n    return columns;\n  }\n}\n"],"mappings":"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"}