@platforma-sdk/model 1.45.35 → 1.45.45

package/src/components/PFrameForGraphs.ts

@@ -23,8 +23,8 @@ import {
   readAnnotationJson,
   stringifyJson,
 } from '@milaboratories/pl-model-common';
-import type { PColumnDataUniversal, RenderCtx } from '../render';
-import { allPColumnsReady, PColumnCollection } from '../render';
+import type { PColumnDataUniversal, PColumnEntryUniversal, PColumnEntryWithLabel, RenderCtx } from '../render';
+import { PColumnCollection } from '../render';
 
 /** Create id for column copy with added keys in axes domains */
 const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
@@ -60,10 +60,14 @@ export function isHiddenFromGraphColumn(column: PColumnSpec): boolean {
   return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
 }
 
+export function isHiddenFromUIColumn(column: PColumnSpec): boolean {
+  return !!readAnnotationJson(column, Annotation.HideDataFromUi);
+}
+
 type AxesVault = Map<CanonicalizedJson<AxisId>, AxisSpecNormalized>;
 
 export function getAvailableWithLinkersAxes(
-  linkerColumns: PColumn<PColumnDataUniversal>[],
+  linkerColumns: (PColumnEntryWithLabel | PColumnEntryUniversal)[],
   blockAxes: AxesVault,
 ): AxesVault {
   const linkerMap = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec));
@@ -90,18 +94,14 @@ export function getAvailableWithLinkersAxes(
   }));
 }
 /** Add columns with fully compatible axes created from partial compatible ones */
-export function enrichCompatible(blockAxes: AxesVault, columns: PColumn<PColumnDataUniversal>[]) {
-  const result: PColumn<PColumnDataUniversal>[] = [];
-  columns.forEach((column) => {
-    result.push(...getAdditionalColumnsForColumn(blockAxes, column));
-  });
-  return result;
+export function enrichCompatible<T extends Omit<PColumn<PColumnDataUniversal>, 'data'>>(blockAxes: AxesVault, columns: T[]): T[] {
+  return columns.flatMap((column) => getAdditionalColumnsForColumn(blockAxes, column));
 }
 
-function getAdditionalColumnsForColumn(
+function getAdditionalColumnsForColumn<T extends Omit<PColumn<PColumnDataUniversal>, 'data'>>(
   blockAxes: AxesVault,
-  column: PColumn<PColumnDataUniversal>,
-): PColumn<PColumnDataUniversal>[] {
+  column: T,
+): T[] {
   const columnAxesIds = column.spec.axesSpec.map(getAxisId);
 
   if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) {
@@ -168,6 +168,7 @@ function getAdditionalColumnsForColumn(
     }
 
     return {
+      ...column,
       id: id as PObjectId,
       spec: {
         ...column.spec,
@@ -177,7 +178,6 @@ function getAdditionalColumnsForColumn(
         })),
         annotations,
       },
-      data: column.data,
     };
   });
 
@@ -200,16 +200,12 @@ export function createPFrameForGraphs<A, U>(
   ctx: RenderCtx<A, U>,
   blockColumns?: PColumn<PColumnDataUniversal>[],
 ): PFrameHandle | undefined {
+  const suitableSpec = (spec: PColumnSpec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
   // if current block doesn't produce own columns then use all columns from result pool
   if (!blockColumns) {
     const columns = new PColumnCollection();
     columns.addColumnProvider(ctx.resultPool);
-
-    const allColumns = columns.getColumns((spec) => !isHiddenFromGraphColumn(spec), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
-    // if at least one column is not yet ready, we can't show the graph
-    if (!allPColumnsReady(allColumns)) {
-      return undefined;
-    }
+    const allColumns = columns.getUniversalEntries(suitableSpec, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
 
     const allAxes: AxesVault = new Map(allColumns
       .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
@@ -224,10 +220,6 @@ export function createPFrameForGraphs<A, U>(
     return ctx.createPFrame(extendedColumns);
   };
 
-  if (!allPColumnsReady(blockColumns)) {
-    return undefined;
-  }
-
   // if current block has its own columns then take from result pool only compatible with them
   const columns = new PColumnCollection();
   columns.addColumnProvider(ctx.resultPool);
@@ -246,7 +238,7 @@ export function createPFrameForGraphs<A, U>(
   }
 
   // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
-  const linkerColumns = columns.getColumns((spec) => isLinkerColumn(spec)) ?? [];
+  const linkerColumns = columns.getUniversalEntries((spec) => suitableSpec(spec) && isLinkerColumn(spec)) ?? [];
   const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
 
   // all possible axes from connected linkers
@@ -257,16 +249,11 @@ export function createPFrameForGraphs<A, U>(
 
   const blockAxesArr = Array.from(blockAxes.values());
   // all compatible with block columns but without label columns
-  let compatibleWithoutLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.some((axisSpec) => {
+  let compatibleWithoutLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.some((axisSpec) => {
     const axisId = getAxisId(axisSpec);
     return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
   }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
 
-  // if at least one column is not yet ready, we can't show the graph
-  if (!allPColumnsReady(compatibleWithoutLabels)) {
-    return undefined;
-  }
-
   // extend axes set for label columns request
   for (const c of compatibleWithoutLabels) {
     for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
@@ -277,22 +264,17 @@ export function createPFrameForGraphs<A, U>(
 
   const allAxesArr = Array.from(allAxes.values());
   // extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
-  compatibleWithoutLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.every((axisSpec) => {
+  compatibleWithoutLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.every((axisSpec) => {
     const axisId = getAxisId(axisSpec);
     return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
   }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
 
   // label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
-  const compatibleLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.some((axisSpec) => {
+  const compatibleLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.some((axisSpec) => {
     const axisId = getAxisId(axisSpec);
     return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
   }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
 
-  // if at least one column is not yet ready, we can't show the graph
-  if (!allPColumnsReady(compatibleLabels)) {
-    return undefined;
-  }
-
   const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
 
   // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match

package/src/filters/converter.ts

@@ -51,6 +51,10 @@ export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionIm
     return col(value.column).eq(lit(value.x));
   }
 
+  if (value.type === 'notEqual') {
+    return col(value.column).neq(lit(value.x));
+  }
+
   if (value.type === 'lessThan') {
     return col(value.column).lt(lit(value.x));
   }
@@ -112,7 +116,6 @@ export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionIm
     || value.type === 'patternFuzzyContainSubsequence'
     || value.type === 'inSet'
     || value.type === 'notInSet'
-    || value.type === 'notEqual'
   ) {
     throw new Error('Not implemented filter type: ' + value.type);
   }

package/src/filters/types.ts

@@ -10,7 +10,7 @@ export type SimplifiedUniversalPColumnEntry = {
 
 export type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> =
   | CommonLeaf & Leaf
-  | CommonNode & { type: 'not'; filter: CommonLeaf & Leaf }
+  | CommonNode & { type: 'not'; filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf> }
   | CommonNode & { type: 'or'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] }
   | CommonNode & { type: 'and'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] };
 

package/src/global.d.ts

@@ -1,9 +1,9 @@
-import type { PlatformaApiVersion } from './platforma';
+import type { Platforma, PlatformaApiVersion } from './platforma';
 
 declare global {
   /** Global factory method returning platforma instance */
   var getPlatforma: PlatformaSDKVersion; // TODO: invalid type
-  var platforma: Platforma;
+  var platforma: undefined | Platforma;
   var platformaApiVersion: PlatformaApiVersion;
 
   function getEnvironmentValue(name: string): string | undefined;

package/src/index.ts

@@ -14,6 +14,7 @@ export * from './block_api_v1';
 export * from './block_api_v2';
 export * from './filters';
 export * from './annotations';
+export * from './pframe_utils';
 
 // reexporting everything from SDK model
 export * from '@milaboratories/pl-model-common';

package/src/internal.ts

@@ -1,5 +1,5 @@
 import type { ValueOrErrors } from '@milaboratories/pl-model-common';
-import {} from './global';
+import { } from './global';
 import type { Platforma, PlatformaApiVersion } from './platforma';
 import type { FutureHandle, GlobalCfgRenderCtx } from './render/internal';
 
@@ -19,7 +19,7 @@ export function getPlatformaInstance<
 >(config?: { sdkVersion: string; apiVersion: PlatformaApiVersion }): Platforma<Args, Outputs, UiState, Href> {
   if (config && typeof globalThis.getPlatforma === 'function')
     return globalThis.getPlatforma(config);
-  else if (typeof globalThis.platforma !== 'undefined') return globalThis.platforma;
+  else if (typeof globalThis.platforma !== 'undefined') return globalThis.platforma as Platforma<Args, Outputs, UiState, Href>;
   else throw new Error('Can\'t get platforma instance.');
 }
 

package/src/pframe.ts

@@ -18,15 +18,15 @@ export class PFrameImpl implements PFrame {
   constructor(private readonly handle: PFrameHandle) {}
 
   public async findColumns(request: FindColumnsRequest): Promise<FindColumnsResponse> {
-    return await platforma.pFrameDriver.findColumns(this.handle, request);
+    return await this.getPlatforma().pFrameDriver.findColumns(this.handle, request);
   }
 
-  public async getColumnSpec(columnId: PObjectId): Promise<PColumnSpec> {
-    return await platforma.pFrameDriver.getColumnSpec(this.handle, columnId);
+  public async getColumnSpec(columnId: PObjectId): Promise<PColumnSpec | null> {
+    return await this.getPlatforma().pFrameDriver.getColumnSpec(this.handle, columnId);
   }
 
   public async listColumns(): Promise<PColumnIdAndSpec[]> {
-    return await platforma.pFrameDriver.listColumns(this.handle);
+    return await this.getPlatforma().pFrameDriver.listColumns(this.handle);
   }
 
   public async calculateTableData(
@@ -39,10 +39,17 @@ export class PFrameImpl implements PFrame {
         filters: patchInSetFilters(request.filters),
       };
     }
-    return await platforma.pFrameDriver.calculateTableData(this.handle, request, range);
+    return await this.getPlatforma().pFrameDriver.calculateTableData(this.handle, request, range);
   }
 
   public async getUniqueValues(request: UniqueValuesRequest): Promise<UniqueValuesResponse> {
-    return await platforma.pFrameDriver.getUniqueValues(this.handle, request);
+    return await this.getPlatforma().pFrameDriver.getUniqueValues(this.handle, request);
+  }
+
+  private getPlatforma() {
+    if (platforma === undefined) {
+      throw new Error('Platforma instance is not available in the current context.');
+    }
+    return platforma;
   }
 }

package/src/pframe_utils/index.ts

@@ -0,0 +1,442 @@
+import { flatten, uniq } from 'es-toolkit';
+
+import type {
+  AxisSpec,
+  CalculateTableDataRequest,
+  PColumnSpec,
+  PFrameHandle,
+  PTableVector,
+  UniqueValuesRequest,
+  AxisId,
+  CanonicalizedJson,
+  FindColumnsRequest,
+  FindColumnsResponse,
+  FullPTableColumnData,
+  PColumnIdAndSpec,
+  PObjectId,
+  PTableRecordSingleValueFilterV2,
+  ValueType,
+} from '@milaboratories/pl-model-common';
+import { pTableValue, Annotation, canonicalizeAxisId, getAxisId, readAnnotation } from '@milaboratories/pl-model-common';
+
+// Types
+type PValue = string | number | null;
+
+type SuggestionResponse = {
+  values: {
+    value: string;
+    label: string;
+  }[];
+  overflow: boolean;
+};
+
+type SingleColumnData = {
+  axesData: Record<string, PValue[]>;
+  data: PValue[];
+};
+
+type UniqueValuesResponse = {
+  values: string[];
+  overflow: boolean;
+};
+
+type GetUniqueSourceValuesParams = {
+  columnId: PObjectId;
+  axisIdx?: number;
+  limit?: number;
+  searchQuery?: string;
+  searchQueryValue?: string;
+};
+
+type GetAxisUniqueValuesParams = {
+  axisId: AxisId;
+  parentColumnIds: PObjectId[];
+  limit?: number;
+  filters?: PTableRecordSingleValueFilterV2[];
+};
+
+type GetColumnsFullParams = {
+  selectedSources: PObjectId[];
+  strictlyCompatible: boolean;
+  types?: ValueType[];
+  names?: string[];
+  annotations?: FindColumnsRequest['columnFilter']['annotationValue'];
+  annotationsNotEmpty?: string[];
+};
+
+// Constants
+const UNIQUE_VALUES_LIMIT = 1000000;
+
+// Helper functions
+const sortValuesPredicate = (a: { label: string }, b: { label: string }) =>
+  a.label.localeCompare(b.label, 'en', { numeric: true });
+
+function convertColumnData(type: ValueType, response: PTableVector, absentValue: number | null = null): PValue[] {
+  if (type === 'String') {
+    return response.data as PValue[];
+  }
+  const res: PValue[] = new Array(response.data.length);
+  for (let i = 0; i < response.data.length; i++) {
+    res[i] = pTableValue(response, i, { absent: absentValue, na: null }) as PValue;
+  }
+  return res;
+}
+
+function createSearchFilter(
+  columnId: PObjectId,
+  substring: string,
+): PTableRecordSingleValueFilterV2 {
+  return {
+    type: 'bySingleColumnV2',
+    column: {
+      type: 'column',
+      id: columnId,
+    },
+    predicate: {
+      operator: 'StringIContains',
+      substring,
+    },
+  };
+}
+
+function createAxisSearchFilter(
+  axisSpec: AxisSpec,
+  substring: string,
+): PTableRecordSingleValueFilterV2 {
+  return {
+    type: 'bySingleColumnV2',
+    column: {
+      type: 'axis',
+      id: {
+        type: axisSpec.type,
+        name: axisSpec.name,
+      },
+    },
+    predicate: {
+      operator: 'StringIContains',
+      substring,
+    },
+  };
+}
+
+function mapValuesToSuggestions(values: string[]): { value: string; label: string }[] {
+  return values.map((v) => ({ value: String(v), label: String(v) })).sort(sortValuesPredicate);
+}
+
+function getPFrameDriver() {
+  if (typeof platforma === 'undefined') {
+    throw new Error('Platforma instance is not available');
+  }
+  if (typeof platforma.pFrameDriver === 'undefined') {
+    throw new Error('PFrame driver is not available in the current Platforma instance');
+  }
+  return platforma.pFrameDriver;
+}
+
+// Core functions
+export async function getColumnSpecById(handle: PFrameHandle, id: PObjectId): Promise<PColumnSpec | null> {
+  try {
+    const response = await getPFrameDriver().getColumnSpec(handle, id);
+    return response ?? null;
+  } catch (err) {
+    console.error('PFrame: get single column error', err);
+    return null;
+  }
+}
+
+export async function getSingleColumnData(
+  handle: PFrameHandle,
+  id: PObjectId,
+  filters: PTableRecordSingleValueFilterV2[] = [],
+): Promise<SingleColumnData> {
+  try {
+    const response: FullPTableColumnData[] = await getPFrameDriver().calculateTableData(handle, {
+      src: {
+        type: 'column',
+        column: id,
+      },
+      filters,
+      sorting: [],
+    } as CalculateTableDataRequest<PObjectId>);
+
+    const axes = response.filter((item) => item.spec.type === 'axis');
+    const columns = response.filter((item) => item.spec.type === 'column');
+
+    return {
+      axesData: axes.reduce((res: Record<string, PValue[]>, item) => {
+        const id = getAxisId(item.spec.spec as AxisSpec);
+        res[canonicalizeAxisId(id)] = convertColumnData(id.type, item.data);
+        return res;
+      }, {}),
+      data: columns.length ? convertColumnData(columns[0].data.type, columns[0].data) : [],
+    };
+  } catch (err) {
+    console.error('PFrame: calculateTableData error');
+    throw err;
+  }
+}
+
+export async function getColumnUniqueValues(
+  handle: PFrameHandle,
+  id: PObjectId,
+  limit = UNIQUE_VALUES_LIMIT,
+  filters: PTableRecordSingleValueFilterV2[] = [],
+): Promise<UniqueValuesResponse> {
+  const request: UniqueValuesRequest = {
+    columnId: id,
+    filters,
+    limit,
+  };
+
+  try {
+    const response = await getPFrameDriver().getUniqueValues(handle, request);
+    if (response.overflow) {
+      console.warn(`More than ${limit} values for ${id} column`);
+    }
+    return {
+      values: Array.from(response.values.data as ArrayLike<unknown>).map(String),
+      overflow: response.overflow,
+    };
+  } catch (err) {
+    console.error('PFrame: getUniqueValues for column error');
+    throw err;
+  }
+}
+
+export async function getAxisUniqueValues(
+  handle: PFrameHandle,
+  params: GetAxisUniqueValuesParams,
+): Promise<UniqueValuesResponse> {
+  const { axisId, parentColumnIds, limit = UNIQUE_VALUES_LIMIT, filters = [] } = params;
+  const strAxisId = canonicalizeAxisId(axisId);
+
+  const parentsSpecs = (await Promise.all(parentColumnIds.map((p) => getColumnSpecById(handle, p))))
+    .flatMap((spec, i): [PObjectId, PColumnSpec][] =>
+      spec != null && spec.kind === 'PColumn' ? [[parentColumnIds[i], spec]] : [],
+    )
+    .filter(([_, spec]) =>
+      spec.axesSpec.some((axisSpec) => canonicalizeAxisId(getAxisId(axisSpec)) === strAxisId),
+    );
+
+  if (parentsSpecs.length === 0) {
+    console.warn('Axis unique values requested without parent columns');
+    return { values: [], overflow: false };
+  }
+
+  try {
+    const responses = await Promise.all(
+      parentsSpecs.map(([id]) =>
+        getPFrameDriver().getUniqueValues(handle, {
+          columnId: id,
+          axis: axisId,
+          filters,
+          limit,
+        }),
+      ),
+    );
+
+    const overflow = responses.some((r) => r.overflow);
+    return {
+      values: uniq(
+        flatten(responses.map((r) =>
+          Array.from(r.values.data as ArrayLike<unknown>).map(String),
+        )),
+      ),
+      overflow,
+    };
+  } catch (err) {
+    console.error('PFrame: getUniqueValues for axis error', err);
+    return { values: [], overflow: false };
+  }
+}
+
+export async function getRequestColumnsFromSelectedSources(
+  handle: PFrameHandle,
+  sources: PObjectId[],
+): Promise<AxisId[]> {
+  const result: AxisId[] = [];
+  for (const item of sources) {
+    const spec = await getColumnSpecById(handle, item);
+    if (spec?.kind === 'PColumn') {
+      result.push(...spec.axesSpec.map((spec) => getAxisId(spec)));
+    }
+  }
+  return result;
+}
+
+export async function getColumnsFull(
+  handle: PFrameHandle,
+  params: GetColumnsFullParams,
+): Promise<PColumnIdAndSpec[]> {
+  const { selectedSources, strictlyCompatible, types, names, annotations, annotationsNotEmpty } = params;
+
+  try {
+    const request: FindColumnsRequest = {
+      columnFilter: {
+        type: types,
+        name: names,
+        annotationValue: annotations,
+        annotationPattern: annotationsNotEmpty?.reduce((res, v) => {
+          res[v] = '.+';
+          return res;
+        }, {} as Record<string, string>),
+      },
+      compatibleWith: await getRequestColumnsFromSelectedSources(handle, selectedSources),
+      strictlyCompatible,
+    };
+
+    const response: FindColumnsResponse = await getPFrameDriver().findColumns(handle, request);
+    return response.hits;
+  } catch (err) {
+    console.error('PFrame: findColumns error');
+    throw err;
+  }
+}
+
+export async function getColumnOrAxisValueLabelsId(
+  handle: PFrameHandle,
+  strAxisId: CanonicalizedJson<AxisId>,
+): Promise<PObjectId | undefined> {
+  const labelColumns = await getColumnsFull(handle, {
+    selectedSources: [],
+    strictlyCompatible: false,
+    names: [Annotation.Label],
+  });
+
+  const labelColumn = labelColumns.find(({ spec }) => {
+    return spec && spec.axesSpec.length === 1 && canonicalizeAxisId(spec.axesSpec[0]) === strAxisId;
+  });
+
+  return labelColumn?.columnId;
+}
+
+function getDiscreteValuesFromAnnotation(columnSpec: PColumnSpec): undefined | SuggestionResponse {
+  const discreteValuesStr = readAnnotation(columnSpec, Annotation.DiscreteValues);
+  if (!discreteValuesStr) {
+    return undefined;
+  }
+
+  try {
+    const discreteValues: string[] = (JSON.parse(discreteValuesStr) as (string | number)[]).map((v) => String(v));
+    const values = discreteValues.map((v) => ({ value: v, label: v })).sort(sortValuesPredicate);
+    return { values, overflow: false };
+  } catch {
+    console.error(`Parsing error: discrete values annotation ${discreteValuesStr}`);
+    return undefined;
+  }
+}
+
+async function getAxisValuesWithLabels(
+  handle: PFrameHandle,
+  params: {
+    columnId: PObjectId;
+    axisSpec: AxisSpec;
+    labelsColumnId: PObjectId | undefined;
+    limit?: number;
+    searchQuery?: string;
+    searchQueryValue?: string;
+  },
+): Promise<SuggestionResponse> {
+  const { columnId, axisSpec, labelsColumnId, limit, searchQuery, searchQueryValue } = params;
+  const strAxisId = canonicalizeAxisId(getAxisId(axisSpec));
+
+  let filters: PTableRecordSingleValueFilterV2[] = [];
+
+  if (labelsColumnId) {
+    if (searchQuery) {
+      filters = [createSearchFilter(labelsColumnId, searchQuery)];
+    }
+    if (searchQueryValue) {
+      filters = [createAxisSearchFilter(axisSpec, searchQueryValue)];
+    }
+
+    const { data: dataValues, axesData } = await getSingleColumnData(handle, labelsColumnId, filters);
+    const axisKeys = axesData[strAxisId];
+    const values: { value: string; label: string }[] = [];
+
+    for (let i = 0; i < Math.min(axisKeys.length, limit ?? axisKeys.length); i++) {
+      values.push({ value: String(axisKeys[i]), label: String(dataValues[i]) });
+    }
+
+    values.sort(sortValuesPredicate);
+    return { values, overflow: !(limit === undefined || axisKeys.length < limit) };
+  } else {
+    const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
+    if (searchInLabelsOrValue) {
+      filters = [createAxisSearchFilter(axisSpec, searchInLabelsOrValue)];
+    }
+
+    const response = await getAxisUniqueValues(handle, {
+      axisId: getAxisId(axisSpec),
+      parentColumnIds: [columnId],
+      limit,
+      filters,
+    });
+
+    const values = mapValuesToSuggestions(response.values);
+    return { values, overflow: response.overflow };
+  }
+}
+
+async function getColumnValuesWithLabels(
+  handle: PFrameHandle,
+  params: {
+    columnId: PObjectId;
+    limit?: number;
+    searchQuery?: string;
+    searchQueryValue?: string;
+  },
+): Promise<SuggestionResponse> {
+  const { columnId, limit, searchQuery, searchQueryValue } = params;
+  const searchInLabelsOrValue = searchQuery ?? searchQueryValue;
+
+  const filters: PTableRecordSingleValueFilterV2[] = searchInLabelsOrValue
+    ? [createSearchFilter(columnId, searchInLabelsOrValue)]
+    : [];
+
+  const response = await getColumnUniqueValues(handle, columnId, limit, filters);
+  const values = mapValuesToSuggestions(response.values);
+  return { values, overflow: response.overflow };
+}
+
+export async function getUniqueSourceValuesWithLabels(
+  handle: PFrameHandle,
+  params: GetUniqueSourceValuesParams,
+): Promise<SuggestionResponse> {
+  const { columnId, axisIdx, limit, searchQuery, searchQueryValue } = params;
+
+  const selectedSourceSpec = await getColumnSpecById(handle, columnId);
+  if (selectedSourceSpec == null || selectedSourceSpec.kind !== 'PColumn') {
+    return { values: [], overflow: false };
+  }
+
+  // Try to get discrete values from annotation
+  const discreteValues = getDiscreteValuesFromAnnotation(selectedSourceSpec);
+  if (discreteValues != null) {
+    return discreteValues;
+  }
+
+  // Handle axis values
+  if (axisIdx != null) {
+    const axisSpec = selectedSourceSpec.axesSpec[axisIdx];
+    const strAxisId = canonicalizeAxisId(getAxisId(axisSpec));
+    const labelsColumnId = await getColumnOrAxisValueLabelsId(handle, strAxisId);
+
+    return getAxisValuesWithLabels(handle, {
+      columnId,
+      axisSpec,
+      labelsColumnId,
+      limit,
+      searchQuery,
+      searchQueryValue,
+    });
+  }
+
+  // Handle column values
+  return getColumnValuesWithLabels(handle, {
+    columnId,
+    limit,
+    searchQuery,
+    searchQueryValue,
+  });
+}