@platforma-sdk/model 1.44.14 → 1.45.17

package/src/filters/converter.test.ts

@@ -0,0 +1,336 @@
+import type { SUniversalPColumnId } from '@milaboratories/pl-model-common';
+import { describe, expect, it } from 'vitest';
+import { convertFilterUiToExpressions } from './converter';
+import { FilterSpec } from './types';
+
+describe('convertFilterUiToExpressions', () => {
+  it('should compile "or" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'or',
+      filters: [
+        { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId },
+        { type: 'patternEquals', column: 'colB' as unknown as SUniversalPColumnId, value: 'test' },
+      ],
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('or');
+    expect((result as any).operands).toHaveLength(2);
+    expect((result as any).operands[0].type).toBe('is_na');
+    expect((result as any).operands[1].type).toBe('eq');
+  });
+
+  it('should compile "and" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'and',
+      filters: [
+        { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId },
+        { type: 'greaterThan', column: 'colNum' as unknown as SUniversalPColumnId, x: 10 },
+      ],
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('and');
+    expect((result as any).operands).toHaveLength(2);
+    expect((result as any).operands[0].type).toBe('is_na');
+    expect((result as any).operands[1].type).toBe('gt');
+  });
+
+  it('should compile "not" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'not',
+      filter: { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId },
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('not');
+    expect((result as any).value.type).toBe('is_na');
+    expect((result as any).value.value.type).toBe('col');
+    expect((result as any).value.value.name).toBe('colA');
+  });
+
+  it('should compile "isNA" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'is_na',
+      value: { type: 'col', name: 'colA' },
+    });
+  });
+
+  it('should compile "isNotNA" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'isNotNA', column: 'colA' as unknown as SUniversalPColumnId };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'is_not_na',
+      value: { type: 'col', name: 'colA' },
+    });
+  });
+
+  it('should compile "patternEquals" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'patternEquals', column: 'colB' as unknown as SUniversalPColumnId, value: 'abc' };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'eq',
+      lhs: { type: 'col', name: 'colB' },
+      rhs: { type: 'const', value: 'abc' },
+    });
+  });
+
+  it('should compile "patternNotEquals" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'patternNotEquals', column: 'colB' as unknown as SUniversalPColumnId, value: 'abc' };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'neq',
+      lhs: { type: 'col', name: 'colB' },
+      rhs: { type: 'const', value: 'abc' },
+    });
+  });
+
+  it('should compile "patternContainSubsequence" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'patternContainSubsequence', column: 'colC' as unknown as SUniversalPColumnId, value: 'sub' };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('str_contains');
+    expect((result as any).value).toEqual({ type: 'col', name: 'colC' });
+    expect((result as any).pattern).toEqual({ type: 'const', value: 'sub' });
+  });
+
+  it('should compile "patternNotContainSubsequence" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'patternNotContainSubsequence', column: 'colC' as unknown as SUniversalPColumnId, value: 'sub' };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('not');
+    expect((result as any).value.type).toBe('str_contains');
+    expect((result as any).value.value).toEqual({ type: 'col', name: 'colC' });
+    expect((result as any).value.pattern).toEqual({ type: 'const', value: 'sub' });
+  });
+
+  it('should compile numerical comparison filters to ptabler expressions', () => {
+    const testCases = [
+      { type: 'equal' as const, expected: 'eq' },
+      { type: 'lessThan' as const, expected: 'lt' },
+      { type: 'greaterThan' as const, expected: 'gt' },
+      { type: 'lessThanOrEqual' as const, expected: 'le' },
+      { type: 'greaterThanOrEqual' as const, expected: 'ge' },
+    ];
+
+    testCases.forEach(({ type, expected }) => {
+      const uiFilter: FilterSpec = { type, column: 'colNum' as unknown as SUniversalPColumnId, x: 10 };
+      const result = convertFilterUiToExpressions(uiFilter);
+      expect(result as any).toEqual({
+        type: expected,
+        lhs: { type: 'col', name: 'colNum' },
+        rhs: { type: 'const', value: 10 },
+      });
+    });
+  });
+
+  it('should compile "lessThanColumn" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'lessThanColumn',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'lt',
+      lhs: { type: 'col', name: 'colNum1' },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "lessThanColumn" filter with minDiff to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'lessThanColumn',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+      minDiff: 5,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'lt',
+      lhs: {
+        type: 'plus',
+        lhs: { type: 'col', name: 'colNum1' },
+        rhs: { type: 'const', value: 5 },
+      },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "greaterThanColumn" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'greaterThanColumn',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'gt',
+      lhs: { type: 'col', name: 'colNum1' },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "greaterThanColumn" filter with minDiff to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'greaterThanColumn',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+      minDiff: 7,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'gt',
+      lhs: {
+        type: 'plus',
+        lhs: { type: 'col', name: 'colNum1' },
+        rhs: { type: 'const', value: 7 },
+      },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "equalToColumn" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'equalToColumn',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'eq',
+      lhs: { type: 'col', name: 'colNum1' },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "greaterThanColumnOrEqual" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'greaterThanColumnOrEqual',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'ge',
+      lhs: { type: 'col', name: 'colNum1' },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "greaterThanColumnOrEqual" filter with minDiff to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'greaterThanColumnOrEqual',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+      minDiff: 2,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'ge',
+      lhs: {
+        type: 'plus',
+        lhs: { type: 'col', name: 'colNum1' },
+        rhs: { type: 'const', value: 2 },
+      },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "lessThanColumnOrEqual" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'lessThanColumnOrEqual',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'le',
+      lhs: { type: 'col', name: 'colNum1' },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "lessThanColumnOrEqual" filter with minDiff to ptabler expression', () => {
+    const uiFilter: FilterSpec = {
+      type: 'lessThanColumnOrEqual',
+      column: 'colNum1' as unknown as SUniversalPColumnId,
+      rhs: 'colNum2' as unknown as SUniversalPColumnId,
+      minDiff: 3,
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'le',
+      lhs: {
+        type: 'plus',
+        lhs: { type: 'col', name: 'colNum1' },
+        rhs: { type: 'const', value: 3 },
+      },
+      rhs: { type: 'col', name: 'colNum2' },
+    });
+  });
+
+  it('should compile "topN" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'topN', column: 'colNum' as unknown as SUniversalPColumnId, n: 5 };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'le',
+      lhs: {
+        type: 'rank',
+        orderBy: [{ type: 'col', name: 'colNum' }],
+        partitionBy: [],
+        descending: true,
+      },
+      rhs: { type: 'const', value: 5 },
+    });
+  });
+
+  it('should compile "bottomN" filter to ptabler expression', () => {
+    const uiFilter: FilterSpec = { type: 'bottomN', column: 'colNum' as unknown as SUniversalPColumnId, n: 3 };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result as any).toEqual({
+      type: 'le',
+      lhs: {
+        type: 'rank',
+        orderBy: [{ type: 'col', name: 'colNum' }],
+        partitionBy: [],
+        descending: undefined, // ptabler-js sets descending to undefined when false
+      },
+      rhs: { type: 'const', value: 3 },
+    });
+  });
+
+  it('should compile nested filters to ptabler expressions', () => {
+    const uiFilter: FilterSpec = {
+      type: 'and',
+      filters: [
+        {
+          type: 'or',
+          filters: [
+            { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId },
+            { type: 'patternEquals', column: 'colB' as unknown as SUniversalPColumnId, value: 'test' },
+          ],
+        },
+        { type: 'greaterThan', column: 'colNum' as unknown as SUniversalPColumnId, x: 10 },
+      ],
+    };
+    const result = convertFilterUiToExpressions(uiFilter);
+    expect(result.type).toBe('and');
+    expect((result as any).operands).toHaveLength(2);
+    expect((result as any).operands[0].type).toBe('or');
+    expect((result as any).operands[0].operands).toHaveLength(2);
+    expect((result as any).operands[1].type).toBe('gt');
+  });
+
+  it('should throw error for OR filter with no operands', () => {
+    const uiFilter: FilterSpec = { type: 'or', filters: [] };
+    expect(() => convertFilterUiToExpressions(uiFilter)).toThrow('OR filter requires at least one operand');
+  });
+
+  it('should throw error for AND filter with no operands', () => {
+    const uiFilter: FilterSpec = { type: 'and', filters: [] };
+    expect(() => convertFilterUiToExpressions(uiFilter)).toThrow('AND filter requires at least one operand');
+  });
+
+  it('should throw error for undefined filter type', () => {
+    const uiFilter: FilterSpec = { type: undefined };
+    expect(() => convertFilterUiToExpressions(uiFilter)).toThrow('Filter type is undefined, this should not happen');
+  });
+});

package/src/filters/converter.ts

@@ -0,0 +1,119 @@
+import { assertNever } from '@milaboratories/pl-model-common';
+import { and, col, lit, or, rank, type Expression, type ExpressionImpl } from '@milaboratories/ptabler-expression-js';
+import type { FilterSpec } from '../filters';
+
+export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionImpl {
+  if (value.type === 'or') {
+    const expressions = value.filters.filter((f) => f.type !== undefined).map(convertFilterUiToExpressionImpl);
+    if (expressions.length === 0) {
+      throw new Error('OR filter requires at least one operand');
+    }
+    return or(...expressions);
+  }
+
+  if (value.type === 'and') {
+    const expressions = value.filters.filter((f) => f.type !== undefined).map(convertFilterUiToExpressionImpl);
+    if (expressions.length === 0) {
+      throw new Error('AND filter requires at least one operand');
+    }
+    return and(...expressions);
+  }
+
+  if (value.type === 'not') {
+    return convertFilterUiToExpressionImpl(value.filter).not();
+  }
+
+  if (value.type === 'isNA') {
+    return col(value.column).isNull();
+  }
+
+  if (value.type === 'isNotNA') {
+    return col(value.column).isNotNull();
+  }
+
+  if (value.type === 'patternEquals') {
+    return col(value.column).eq(lit(value.value));
+  }
+
+  if (value.type === 'patternNotEquals') {
+    return col(value.column).neq(lit(value.value));
+  }
+
+  if (value.type === 'patternContainSubsequence') {
+    return col(value.column).strContains(value.value, false, true);
+  }
+
+  if (value.type === 'patternNotContainSubsequence') {
+    return col(value.column).strContains(value.value, false, true).not();
+  }
+
+  if (value.type === 'equal') {
+    return col(value.column).eq(lit(value.x));
+  }
+
+  if (value.type === 'lessThan') {
+    return col(value.column).lt(lit(value.x));
+  }
+
+  if (value.type === 'greaterThan') {
+    return col(value.column).gt(lit(value.x));
+  }
+
+  if (value.type === 'lessThanOrEqual') {
+    return col(value.column).le(lit(value.x));
+  }
+
+  if (value.type === 'greaterThanOrEqual') {
+    return col(value.column).ge(lit(value.x));
+  }
+
+  if (value.type === 'equalToColumn') {
+    return col(value.column).eq(col(value.rhs));
+  }
+
+  if (value.type === 'greaterThanColumn') {
+    if (value.minDiff !== undefined && value.minDiff !== 0) {
+      return col(value.column).plus(lit(value.minDiff)).gt(col(value.rhs));
+    }
+    return col(value.column).gt(col(value.rhs));
+  }
+
+  if (value.type === 'lessThanColumn') {
+    if (value.minDiff !== undefined && value.minDiff !== 0) {
+      return col(value.column).plus(lit(value.minDiff)).lt(col(value.rhs));
+    }
+    return col(value.column).lt(col(value.rhs));
+  }
+
+  if (value.type === 'greaterThanColumnOrEqual') {
+    if (value.minDiff !== undefined && value.minDiff !== 0) {
+      return col(value.column).plus(lit(value.minDiff)).ge(col(value.rhs));
+    }
+    return col(value.column).ge(col(value.rhs));
+  }
+
+  if (value.type === 'lessThanColumnOrEqual') {
+    if (value.minDiff !== undefined && value.minDiff !== 0) {
+      return col(value.column).plus(lit(value.minDiff)).le(col(value.rhs));
+    }
+    return col(value.column).le(col(value.rhs));
+  }
+
+  if (value.type === 'topN') {
+    return rank(col(value.column), true).over([]).le(lit(value.n));
+  }
+
+  if (value.type === 'bottomN') {
+    return rank(col(value.column), false).over([]).le(lit(value.n));
+  }
+
+  if (value.type === undefined) {
+    throw new Error('Filter type is undefined, this should not happen');
+  }
+
+  assertNever(value);
+}
+
+export function convertFilterUiToExpressions(value: FilterSpec): Expression {
+  return convertFilterUiToExpressionImpl(value).toJSON();
+}

package/src/filters/index.ts

@@ -0,0 +1,2 @@
+export * from './converter';
+export * from './types';

package/src/filters/types.ts

@@ -0,0 +1,47 @@
+import type { PColumnSpec, SUniversalPColumnId } from '@milaboratories/pl-model-common';
+
+export type SimplifiedPColumnSpec = Pick<PColumnSpec, 'valueType' | 'annotations'>;
+
+export type SimplifiedUniversalPColumnEntry = {
+  id: SUniversalPColumnId;
+  label: string;
+  obj: SimplifiedPColumnSpec;
+};
+
+export type FilterSpecNode<Leaf, Common = {}> =
+  | Common & Leaf
+  | Common & { type: 'not'; filter: Common & Leaf }
+  | Common & { type: 'or'; filters: FilterSpecNode<Leaf, Common>[] }
+  | Common & { type: 'and'; filters: FilterSpecNode<Leaf, Common>[] };
+
+export type FilterSpecLeaf =
+  | { type: undefined }
+  | { type: 'isNA'; column: SUniversalPColumnId }
+  | { type: 'isNotNA'; column: SUniversalPColumnId }
+
+  | { type: 'patternEquals'; column: SUniversalPColumnId; value: string }
+  | { type: 'patternNotEquals'; column: SUniversalPColumnId; value: string }
+  | { type: 'patternContainSubsequence'; column: SUniversalPColumnId; value: string }
+  | { type: 'patternNotContainSubsequence'; column: SUniversalPColumnId; value: string }
+
+  | { type: 'topN'; column: SUniversalPColumnId; n: number }
+  | { type: 'bottomN'; column: SUniversalPColumnId; n: number }
+
+  | { type: 'equal'; column: SUniversalPColumnId; x: number }
+  | { type: 'lessThan'; column: SUniversalPColumnId; x: number }
+  | { type: 'greaterThan'; column: SUniversalPColumnId; x: number }
+  | { type: 'lessThanOrEqual'; column: SUniversalPColumnId; x: number }
+  | { type: 'greaterThanOrEqual'; column: SUniversalPColumnId; x: number }
+
+  | { type: 'equalToColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId }
+  | { type: 'lessThanColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
+  | { type: 'greaterThanColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
+  | { type: 'lessThanColumnOrEqual'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
+  | { type: 'greaterThanColumnOrEqual'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number };
+
+export type FilterSpec<Leaf extends FilterSpecLeaf = FilterSpecLeaf, Common = {}> =
+  FilterSpecNode<Leaf, Common>;
+
+export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>['type'];
+
+export type FilterSpecOfType<T extends FilterSpecType> = Extract<FilterSpec, { type: T }>;

package/src/index.ts

@@ -12,6 +12,8 @@ export * from './sdk_info';
 export * from './raw_globals';
 export * from './block_api_v1';
 export * from './block_api_v2';
+export * from './filters';
+export * from './annotations';
 
 // reexporting everything from SDK model
 export * from '@milaboratories/pl-model-common';

package/src/render/api.ts

@@ -53,6 +53,7 @@ import type { LabelDerivationOps } from './util/label';
 import { deriveLabels } from './util/label';
 import type { APColumnSelectorWithSplit } from './util/split_selectors';
 import { patchInSetFilters } from './util/pframe_upgraders';
+import { allPColumnsReady } from './util/pcolumn_data';
 
 export type PColumnDataUniversal = TreeNodeAccessor | DataInfo<TreeNodeAccessor> | PColumnValues;
 
@@ -618,21 +619,22 @@ export class RenderCtx<Args, UiState> {
   }
 
   // TODO remove all non-PColumn fields
-  public createPFrame(def: PFrameDef<PColumnDataUniversal>): PFrameHandle {
+  public createPFrame(def: PFrameDef<PColumnDataUniversal>): PFrameHandle | undefined {
     this.verifyInlineAndExplicitColumnsSupport(def);
+    if (!allPColumnsReady(def)) return undefined;
     return this.ctx.createPFrame(
       def.map((c) => transformPColumnData(c)),
     );
   }
 
   // TODO remove all non-PColumn fields
-  public createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle;
+  public createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;
   public createPTable(def: {
     columns: PColumn<PColumnDataUniversal>[];
     filters?: PTableRecordFilter[];
     /** Table sorting */
     sorting?: PTableSorting[];
-  }): PTableHandle;
+  }): PTableHandle | undefined;
   public createPTable(
     def:
       | PTableDef<PColumn<PColumnDataUniversal>>
@@ -642,7 +644,7 @@ export class RenderCtx<Args, UiState> {
         /** Table sorting */
         sorting?: PTableSorting[];
       },
-  ): PTableHandle {
+  ): PTableHandle | undefined {
     let rawDef: PTableDef<PColumn<PColumnDataUniversal>>;
     if ('columns' in def) {
       rawDef = this.patchPTableDef({
@@ -657,7 +659,9 @@ export class RenderCtx<Args, UiState> {
     } else {
       rawDef = this.patchPTableDef(def);
     }
-    this.verifyInlineAndExplicitColumnsSupport(extractAllColumns(rawDef.src));
+    const columns = extractAllColumns(rawDef.src);
+    this.verifyInlineAndExplicitColumnsSupport(columns);
+    if (!allPColumnsReady(columns)) return undefined;
     return this.ctx.createPTable(
       mapPTableDef(rawDef, (po) => transformPColumnData(po)),
     );

package/src/render/util/column_collection.ts

@@ -1,39 +1,39 @@
 import type {
   AnchoredIdDeriver,
+  AnchoredPColumnSelector,
+  AxisFilterByIdx,
+  AxisFilterValue,
   AxisId,
+  NativePObjectId,
+  PartitionedDataInfoEntries,
   PColumn,
   PColumnSelector,
   PColumnSpec,
+  PColumnValues,
   PObjectId,
-  SUniversalPColumnId,
-  AxisFilterValue,
-  AxisFilterByIdx,
-  AnchoredPColumnSelector,
-  PartitionedDataInfoEntries,
   ResolveAnchorsOptions,
-  NativePObjectId,
-  PColumnValues,
+  SUniversalPColumnId,
 } from '@milaboratories/pl-model-common';
 import {
-  selectorsToPredicate,
-  resolveAnchors,
-  getAxisId,
-  isPColumnSpec,
+  Annotation,
   canonicalizeAxisId,
-  isPartitionedDataInfoEntries,
-  entriesToDataInfo,
   deriveNativeId,
-  Annotation,
+  entriesToDataInfo,
+  getAxisId,
+  isPartitionedDataInfoEntries,
+  isPColumnSpec,
+  resolveAnchors,
+  selectorsToPredicate,
 } from '@milaboratories/pl-model-common';
+import canonicalize from 'canonicalize';
+import type { Optional } from 'utility-types';
 import type { TreeNodeAccessor } from '../accessor';
+import type { PColumnDataUniversal } from '../api';
+import { filterDataInfoEntries } from './axis_filtering';
 import type { LabelDerivationOps, TraceEntry } from './label';
 import { deriveLabels } from './label';
-import type { Optional } from 'utility-types';
+import { convertOrParsePColumnData, getUniquePartitionKeys } from './pcolumn_data';
 import type { APColumnSelectorWithSplit, PColumnSelectorWithSplit } from './split_selectors';
-import canonicalize from 'canonicalize';
-import { getUniquePartitionKeys, convertOrParsePColumnData } from './pcolumn_data';
-import { filterDataInfoEntries } from './axis_filtering';
-import type { PColumnDataUniversal } from '../api';
 
 function isPColumnValues(value: unknown): value is PColumnValues {
   if (!Array.isArray(value)) return false;

package/src/render/util/pcolumn_data.ts

@@ -1,17 +1,21 @@
 import type {
   DataInfo,
   PartitionedDataInfoEntries,
+  PColumn,
+  PColumnValues,
 } from '@milaboratories/pl-model-common';
 import {
   dataInfoToEntries,
   isDataInfo,
   isDataInfoEntries,
+  visitDataInfo,
   type BinaryChunk,
   type DataInfoEntries,
   type PColumnDataEntry,
   type PColumnKey,
 } from '@milaboratories/pl-model-common';
 import { TreeNodeAccessor } from '../accessor';
+import type { PColumnDataUniversal } from '../api';
 
 const PCD_PREFIX = 'PColumnData/';
 
@@ -507,3 +511,23 @@ DataInfoEntries<TreeNodeAccessor> | undefined {
 
   throw new Error(`Unexpected input type: ${typeof acc}`);
 }
+
+export function isPColumnReady(c: PColumn<PColumnDataUniversal>): boolean {
+  const isValues = (d: PColumnDataUniversal): d is PColumnValues => Array.isArray(d);
+  const isAccessor = (d: PColumnDataUniversal): d is TreeNodeAccessor => d instanceof TreeNodeAccessor;
+
+  let ready = true;
+  if (isAccessor(c.data)) {
+    ready &&= c.data.getIsReadyOrError();
+  } else if (isDataInfo(c.data)) {
+    visitDataInfo(c.data, (v) => ready &&= v.getIsReadyOrError());
+  } else if (!isValues(c.data)) {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    throw Error(`unsupported column data type: ${c.data satisfies never}`);
+  }
+  return ready;
+}
+
+export function allPColumnsReady(columns: PColumn<PColumnDataUniversal>[]): boolean {
+  return columns.every(isPColumnReady);
+}