@platforma-sdk/model 1.45.0 → 1.45.23

package/src/components/PlDataTable.ts

@@ -34,10 +34,11 @@ import type {
   ColumnProvider,
   PColumnDataUniversal,
   RenderCtx,
+  TreeNodeAccessor,
 } from '../render';
 import {
+  allPColumnsReady,
   PColumnCollection,
-  TreeNodeAccessor,
 } from '../render';
 import { isLinkerColumn } from './PFrameForGraphs';
 
@@ -576,44 +577,6 @@ export function getMatchingLabelColumns(
   return labelColumns;
 }
 
-/** Check if all columns are computed */
-export function allColumnsComputed(
-  columns: PColumn<PColumnValues | TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[],
-): boolean {
-  type Data = typeof columns[number]['data'];
-  const isValues = (d: Data): d is PColumnValues => Array.isArray(d);
-  const isAccessor = (d: Data): d is TreeNodeAccessor => d instanceof TreeNodeAccessor;
-  const isDataInfo = (d: Data): d is DataInfo<TreeNodeAccessor> =>
-    typeof d === 'object' && 'type' in d;
-
-  return columns
-    .map((c) => c.data)
-    .every((d): boolean => {
-      if (isValues(d)) {
-        return true;
-      } else if (isAccessor(d)) {
-        return d.getIsReadyOrError();
-      } else if (isDataInfo(d)) {
-        const type = d.type;
-        switch (type) {
-          case 'Json':
-            return true;
-          case 'JsonPartitioned':
-            return Object.values(d.parts).every((p) => p.getIsReadyOrError());
-          case 'BinaryPartitioned':
-            return Object.values(d.parts)
-              .every((p) => p.index.getIsReadyOrError() && p.values.getIsReadyOrError());
-          case 'ParquetPartitioned':
-            return Object.values(d.parts)
-              .every((p) => p.getIsReadyOrError());
-        }
-      } else {
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        throw Error(`unsupported column data type: ${d satisfies never}`);
-      }
-    });
-}
-
 function createPTableDef(params: {
   columns: PColumn<PColumnDataUniversal>[];
   labelColumns: PColumn<PColumnDataUniversal>[];
@@ -745,6 +708,7 @@ export function createPlDataTableV2<A, U>(
     coreColumnPredicate: ops?.coreColumnPredicate,
   });
   const fullHandle = ctx.createPTable(fullDef);
+  if (!fullHandle) return undefined;
 
   const hiddenColumns = new Set<PObjectId>(((): PObjectId[] => {
     // Inner join works as a filter - all columns must be present
@@ -779,7 +743,7 @@ export function createPlDataTableV2<A, U>(
   const visibleLabelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
 
   // if at least one column is not yet computed, we can't show the table
-  if (!allColumnsComputed([...visibleColumns, ...visibleLabelColumns])) return undefined;
+  if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;
 
   const visibleDef = createPTableDef({
     columns: visibleColumns,
@@ -791,6 +755,7 @@ export function createPlDataTableV2<A, U>(
     coreColumnPredicate,
   });
   const visibleHandle = ctx.createPTable(visibleDef);
+  if (!visibleHandle) return undefined;
 
   return {
     sourceId: tableStateNormalized.pTableParams.sourceId,

package/src/filters/types.ts

@@ -8,11 +8,11 @@ export type SimplifiedUniversalPColumnEntry = {
   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 FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> =
+  | CommonLeaf & Leaf
+  | CommonNode & { type: 'not'; filter: CommonLeaf & Leaf }
+  | CommonNode & { type: 'or'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] }
+  | CommonNode & { type: 'and'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] };
 
 export type FilterSpecLeaf =
   | { type: undefined }
@@ -39,8 +39,8 @@ export type FilterSpecLeaf =
   | { 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 FilterSpec<Leaf extends FilterSpecLeaf = FilterSpecLeaf, CommonNode = {}, CommonLeaf = CommonNode> =
+  FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
 
 export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>['type'];
 

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/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);
+}