@platforma-sdk/model 1.44.14 → 1.45.17

package/src/components/PlAnnotations/filters_ui.ts

@@ -1,64 +1,59 @@
+// @DEPRECATED - use sdk/model/src/filters + sdk/model/src/annotations
 import type { SUniversalPColumnId } from '@milaboratories/pl-model-common';
+import type { FilterSpecUi } from '../../annotations';
+import type { FilterSpec } from '../../filters';
 import type { AnnotationFilter, AnnotationMode, AnnotationScript, IsNA, NotFilter, NumericalComparisonFilter, PatternFilter, PatternPredicate, ValueRank } from './filter';
-import type { SimplifiedPColumnSpec } from './types';
 
-export function unreachable(x: never): never {
-  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-  throw new Error('Unexpected object: ' + x);
-}
-
-function isNumericValueType(spec: SimplifiedPColumnSpec): boolean {
-  return spec.valueType === 'Int' || spec.valueType === 'Long' || spec.valueType === 'Float' || spec.valueType === 'Double';
-}
-
-function isStringValueType(spec: SimplifiedPColumnSpec): boolean {
-  return spec.valueType === 'String';
-}
-
-// Define recursive type explicitly
-export type FilterUi = { id?: number; name?: string; isExpanded?: boolean }
-  & ({ type: undefined }
-    | { type: 'or'; filters: FilterUi[] }
-    | { type: 'and'; filters: FilterUi[] }
-    | { type: 'not'; filter: FilterUi }
-    | { 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: 'lessThan'; column: SUniversalPColumnId; x: number }
-    | { type: 'greaterThan'; column: SUniversalPColumnId; x: number }
-    | { type: 'lessThanOrEqual'; column: SUniversalPColumnId; x: number }
-    | { type: 'greaterThanOrEqual'; column: SUniversalPColumnId; x: number }
-    | { type: 'lessThanColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
-    | { type: 'lessThanColumnOrEqual'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number });
+export type FilterUi = FilterSpec<Extract<
+  FilterSpec,
+  // supported filters
+  { type:
+    | 'lessThan'
+    | 'greaterThan'
+    | 'lessThanOrEqual'
+    | 'greaterThanOrEqual'
+    | 'lessThanColumn'
+    | 'lessThanColumnOrEqual'
+    | 'patternContainSubsequence'
+    | 'patternNotContainSubsequence'
+    | 'patternEquals'
+    | 'patternNotEquals'
+    | 'topN'
+    | 'bottomN'
+    | 'isNA'
+    | 'isNotNA';
+  }
+>, { id?: number; name?: string; isExpanded?: boolean }>;
 
 export type FilterUiType = Exclude<FilterUi, { type: undefined }>['type'];
 
 export type FilterUiOfType<T extends FilterUiType> = Extract<FilterUi, { type: T }>;
 
+// DEPRECATED - use lib/ui/uikit/src/composition/filters
+export function unreachable(x: never): never {
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  throw new Error('Unexpected object: ' + x);
+}
+
 export type TypeToLiteral<T> =
-[T] extends [FilterUiType] ? 'FilterUiType' :
-    [T] extends [SUniversalPColumnId] ? 'SUniversalPColumnId' :
-        [T] extends [PatternPredicate] ? 'PatternPredicate' :
-            [T] extends [AnnotationFilter[]] ? 'AnnotationFilter[]' :
-                [T] extends [AnnotationFilter] ? 'AnnotationFilter' :
-                    [T] extends [number] ? 'number' :
-                        [T] extends [number | undefined] ? 'number?' :
-                            [T] extends [string] ? 'string' :
-                                [T] extends [string | undefined] ? 'string?' :
-                                    [T] extends [boolean] ? 'boolean' :
-                                        [T] extends [boolean | undefined] ? 'boolean?' :
-                                            [T] extends [unknown[]] ? 'unknown[]' :
-                                            // this is special
-                                              T extends number ? 'number' :
-                                                T extends string ? 'string' :
-                                                  T extends boolean ? 'boolean' :
-                                                    T extends Record<string, unknown> ? 'form' :
-                                                      'unknown';
+  [T] extends [FilterUiType] ? 'FilterUiType' :
+      [T] extends [SUniversalPColumnId] ? 'SUniversalPColumnId' :
+          [T] extends [PatternPredicate] ? 'PatternPredicate' :
+              [T] extends [AnnotationFilter[]] ? 'AnnotationFilter[]' :
+                  [T] extends [AnnotationFilter] ? 'AnnotationFilter' :
+                      [T] extends [number] ? 'number' :
+                          [T] extends [number | undefined] ? 'number?' :
+                              [T] extends [string] ? 'string' :
+                                  [T] extends [string | undefined] ? 'string?' :
+                                      [T] extends [boolean] ? 'boolean' :
+                                          [T] extends [boolean | undefined] ? 'boolean?' :
+                                              [T] extends [unknown[]] ? 'unknown[]' :
+                                              // this is special
+                                                T extends number ? 'number' :
+                                                  T extends string ? 'string' :
+                                                    T extends boolean ? 'boolean' :
+                                                      T extends Record<string, unknown> ? 'form' :
+                                                        'unknown';
 
 // @TODO: "parse" option
 export type TypeField<V> = {
@@ -67,7 +62,7 @@ export type TypeField<V> = {
   defaultValue: () => V | undefined;
 };
 
-export type TypeFieldRecord<T> = { [K in keyof T]: TypeField<T[K]>; };
+export type TypeFieldRecord<T extends FilterUi> = { [K in keyof T]: TypeField<T[K]>; };
 
 export type TypeForm<T> = {
   [P in keyof T]: T[P] extends Record<string, unknown> ? {
@@ -94,377 +89,16 @@ export type FormField =
 
 export type AnyForm = Record<string, FormField>;
 
-type CreateFilterUiMetadataMap<T extends FilterUiType> = {
-  [P in T]: {
-    label: string;
-    form: TypeForm<FilterUiOfType<T>>; // TODO: simplify this to `TypeField<T>`
-    supportedFor: (spec1: SimplifiedPColumnSpec, spec2: SimplifiedPColumnSpec | undefined) => boolean;
-  }
+export type AnnotationStepUi = FilterSpecUi<FilterUi> & {
+  id?: number;
 };
 
-export const filterUiMetadata = {
-  lessThan: {
-    label: 'Col < X (Less Than)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'lessThan',
-      },
-      x: {
-        label: 'X',
-        fieldType: 'number',
-        defaultValue: () => 0,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  greaterThan: {
-    label: 'Col > X (Greater Than)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'greaterThan',
-      },
-      x: {
-        label: 'X',
-        fieldType: 'number',
-        defaultValue: () => 0,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  lessThanOrEqual: {
-    label: 'Col ≤ X (Less Than or Equal)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'lessThanOrEqual',
-      },
-      x: {
-        label: 'X',
-        fieldType: 'number',
-        defaultValue: () => 0,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  greaterThanOrEqual: {
-    label: 'Col ≥ X (Greater Than or Equal)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'greaterThanOrEqual',
-      },
-      x: {
-        label: 'X',
-        fieldType: 'number',
-        defaultValue: () => 0,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  lessThanColumn: {
-    label: 'Col₁ < Col₂ (Compare Columns)',
-    form: {
-      column: {
-        label: 'Col₁',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'lessThanColumn',
-      },
-      rhs: {
-        label: 'Col₂',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      minDiff: {
-        label: 'Margin (positive)',
-        fieldType: 'number?',
-        defaultValue: () => undefined,
-      },
-    },
-    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
-      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
-    },
-  },
-  lessThanColumnOrEqual: {
-    label: 'Col₁ ≤ Col₂ (Compare Columns)',
-    form: {
-      column: {
-        label: 'Col₁',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'lessThanColumnOrEqual',
-      },
-      rhs: {
-        label: 'Col₂',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      minDiff: {
-        label: 'Margin (positive)',
-        fieldType: 'number?',
-        defaultValue: () => undefined,
-      },
-    },
-    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
-      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
-    },
-  },
-  topN: {
-    label: 'Top N',
-    form: {
-      column: {
-        label: 'Rank By Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'topN',
-      },
-      n: {
-        label: 'N',
-        fieldType: 'number',
-        defaultValue: () => 10,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  bottomN: {
-    label: 'Bottom N',
-    form: {
-      column: {
-        label: 'Rank By Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'bottomN',
-      },
-      n: {
-        label: 'N',
-        fieldType: 'number',
-        defaultValue: () => 10,
-      },
-    },
-    supportedFor: isNumericValueType,
-  },
-  patternContainSubsequence: {
-    label: 'Col ~ Seq (Contain Subsequence)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'patternContainSubsequence',
-      },
-      value: {
-        label: 'Seq',
-        fieldType: 'string',
-        defaultValue: () => '',
-      },
-    },
-    supportedFor: isStringValueType,
-  },
-  patternNotContainSubsequence: {
-    label: 'Col ≁ Seq (Not Contain Subsequence)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'patternNotContainSubsequence',
-      },
-      value: {
-        label: 'Seq',
-        fieldType: 'string',
-        defaultValue: () => '',
-      },
-    },
-    supportedFor: isStringValueType,
-  },
-  patternEquals: {
-    label: 'Col = Seq (Equals)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'patternEquals',
-      },
-      value: {
-        label: 'Seq',
-        fieldType: 'string',
-        defaultValue: () => '',
-      },
-    },
-    supportedFor: isStringValueType,
-  },
-  patternNotEquals: {
-    label: 'Col ≠ Seq (Not Equal)',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'patternNotEquals',
-      },
-      value: {
-        label: 'Seq',
-        fieldType: 'string',
-        defaultValue: () => '',
-      },
-    },
-    supportedFor: isStringValueType,
-  },
-  isNA: {
-    label: 'Is NA',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'isNA',
-      },
-    },
-    supportedFor: () => true,
-  },
-  isNotNA: {
-    label: 'Is Not NA',
-    form: {
-      column: {
-        label: 'Column',
-        fieldType: 'SUniversalPColumnId',
-        defaultValue: () => undefined,
-      },
-      type: {
-        label: 'Predicate',
-        fieldType: 'FilterUiType',
-        defaultValue: () => 'isNotNA',
-      },
-    },
-    supportedFor: () => true,
-  },
-  or: {
-    label: 'Or',
-    form: {
-      type: {
-        fieldType: 'FilterUiType',
-        label: 'Predicate',
-        defaultValue: () => 'or',
-      },
-      filters: {
-        fieldType: 'unknown[]',
-        label: 'Filters',
-        defaultValue: () => [],
-      },
-    },
-    supportedFor: () => false,
-  },
-  and: {
-    label: 'And',
-    form: {
-      type: {
-        fieldType: 'FilterUiType',
-        label: 'Predicate',
-        defaultValue: () => 'and',
-      },
-      filters: {
-        fieldType: 'unknown[]',
-        label: 'Filters',
-        defaultValue: () => [],
-      },
-    },
-    supportedFor: () => false,
-  },
-  not: {
-    label: 'Not',
-    form: {
-      type: {
-        fieldType: 'FilterUiType',
-        label: 'Predicate',
-        defaultValue: () => 'not',
-      },
-      filter: {
-        fieldType: 'form',
-        label: 'Filter',
-        defaultValue: () => undefined as unknown as FilterUi, // TODO:
-      },
-    },
-    supportedFor: () => false,
-  },
-} satisfies CreateFilterUiMetadataMap<FilterUiType>;
-
-export function getFilterUiTypeOptions(columnSpec?: SimplifiedPColumnSpec) {
-  if (!columnSpec) {
-    return [];
-  }
-
-  return Object.entries(filterUiMetadata).filter(([_, metadata]) => metadata.supportedFor(columnSpec)).map(([type, metadata]) => ({
-    label: metadata.label,
-    value: type,
-  }));
-}
-
-export function getFilterUiMetadata(type: FilterUiType) {
-  return filterUiMetadata[type];
-}
+export type AnnotationScriptUi = {
+  isCreated?: boolean;
+  title: string;
+  mode: AnnotationMode;
+  steps: AnnotationStepUi[];
+};
 
 export function compileFilter(ui: FilterUi): AnnotationFilter {
   if (ui.type === 'or') {
@@ -626,10 +260,6 @@ export function compileFilter(ui: FilterUi): AnnotationFilter {
     };
   }
 
-  if (ui.type === undefined) {
-    throw new Error('Filter type is undefined, this should not happen');
-  }
-
   unreachable(ui);
 }
 
@@ -637,19 +267,6 @@ export function compileFilters(uiFilters: FilterUi[]): AnnotationFilter[] {
   return uiFilters.filter((f) => f.type !== undefined).map(compileFilter);
 }
 
-export type AnnotationStepUi = {
-  id?: number;
-  label: string;
-  filter: Extract<FilterUi, { type: 'and' | 'or' }>;
-};
-
-export type AnnotationScriptUi = {
-  isCreated?: boolean;
-  title: string;
-  mode: AnnotationMode;
-  steps: AnnotationStepUi[];
-};
-
 export function compileAnnotationScript(uiScript: AnnotationScriptUi): AnnotationScript {
   return {
     title: uiScript.title,

package/src/components/PlAnnotations/index.ts

@@ -1,2 +1,3 @@
+// @DEPRECATED - use sdk/model/src/filters + sdk/model/src/annotations
 export * from './filter';
 export * from './filters_ui';

package/src/components/PlAnnotations/types.ts

@@ -1,3 +1,4 @@
+// @DEPRECATED - use sdk/model/src/filters + sdk/model/src/annotations
 import type { PColumnSpec } from '@milaboratories/pl-model-common';
 
 export type SimplifiedPColumnSpec = Pick<PColumnSpec, 'valueType' | 'annotations'>;

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/components/index.ts

@@ -1,5 +1,5 @@
 export * from './PFrameForGraphs';
+export * from './PlAnnotations';
 export * from './PlDataTable';
 export * from './PlMultiSequenceAlignment';
 export * from './PlSelectionModel';
-export * from './PlAnnotations';