@platforma-sdk/model 1.44.13 → 1.45.0

package/src/annotations/converter.test.ts

@@ -0,0 +1,74 @@
+import type { SUniversalPColumnId } from '@milaboratories/pl-model-common';
+import { describe, expect, test } from 'vitest';
+import { convertFilterSpecsToExpressionSpecs } from './converter';
+import { FilterSpecUi } from './types';
+
+describe('convertFilterSpecsToExpressionSpecs', () => {
+  test('should compile an empty annotation script', () => {
+    const script = convertFilterSpecsToExpressionSpecs([]);
+    expect(script).toEqual([]);
+  });
+
+  test('should compile an annotation script with steps', () => {
+    const filters: FilterSpecUi[] = [
+        {
+          label: 'Step 1',
+          filter: {
+            type: 'and',
+            filters: [
+              { type: 'isNA', column: 'colA' as unknown as SUniversalPColumnId },
+              { type: 'patternEquals', column: 'colB' as unknown as SUniversalPColumnId, value: 'abc' },
+            ],
+          },
+        },
+      ];
+    const expected = [
+      {
+        "name": "Step 1",
+        "type": "alias",
+        "value": {
+          "conditions": [
+            {
+              "then": {
+                "type": "const",
+                "value": true,
+              },
+              "when": {
+                "operands": [
+                  {
+                    "type": "is_na",
+                    "value": {
+                      "name": "colA",
+                      "type": "col",
+                    },
+                  },
+                  {
+                    "lhs": {
+                      "name": "colB",
+                      "type": "col",
+                    },
+                    "rhs": {
+                      "type": "const",
+                      "value": "abc",
+                    },
+                    "type": "eq",
+                  },
+                ],
+                "type": "and",
+              },
+            },
+          ],
+          "otherwise": {
+            "type": "const",
+            "value": false,
+          },
+          "type": "when_then_otherwise",
+        }
+      },
+    ];
+    const script = convertFilterSpecsToExpressionSpecs(filters);
+    expect(script).toEqual(expected);
+  });
+});
+
+

package/src/annotations/converter.ts

@@ -0,0 +1,28 @@
+import { when } from '@milaboratories/ptabler-expression-js';
+import { convertFilterUiToExpressionImpl } from '../filters/converter';
+import type { ExpressionSpec, FilterSpecUi } from './types';
+
+export function convertFilterSpecsToExpressionSpecs(annotationsUI: FilterSpecUi[]): ExpressionSpec[] {
+  return annotationsUI
+    .filter((annotation) => {
+      // No need to convert empty steps
+      if (annotation.filter.type == null) {
+        return false;
+      }
+
+      if (annotation.filter.type === 'or') {
+        return annotation.filter.filters.length > 0;
+      }
+
+      if (annotation.filter.type === 'and') {
+        return annotation.filter.filters.length > 0;
+      }
+
+      return false;
+    })
+    .map((step): ExpressionSpec => ({
+      type: 'alias',
+      name: step.label.trim(),
+      value: when(convertFilterUiToExpressionImpl(step.filter)).then(true).otherwise(false).toJSON(),
+    }));
+}

package/src/annotations/index.ts

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

package/src/annotations/types.ts

@@ -0,0 +1,23 @@
+import type { Expression } from '@milaboratories/ptabler-expression-js';
+import type { FilterSpec } from '../filters';
+
+export type AnnotationSpec<T extends ExpressionSpec = ExpressionSpec> = {
+  title: string;
+  steps: T[];
+};
+
+export type ExpressionSpec<T extends Expression = Expression> = {
+  type: 'alias';
+  name: string;
+  value: T;
+}; // | OtherExpressionSpecTypesInFuture;
+
+export type AnnotationSpecUi<T extends FilterSpecUi = FilterSpecUi> = {
+  title: string;
+  steps: T[];
+};
+
+export type FilterSpecUi<T extends FilterSpec = Extract<FilterSpec, { type: 'and' | 'or' }>> = {
+  label: string;
+  filter: T;
+};

package/src/components/PlAnnotations/filter.ts

@@ -1,3 +1,4 @@
+// @DEPRECATED - use sdk/model/src/filters + sdk/model/src/annotations
 import type { SUniversalPColumnId } from '@milaboratories/pl-model-common';
 //
 // Sequence filter

package/src/components/PlAnnotations/filters_ui.test.ts

@@ -1,3 +1,4 @@
+// @DEPRECATED - use sdk/model/src/filters + sdk/model/src/annotations
 import type { SUniversalPColumnId } from '@milaboratories/pl-model-common';
 import { describe, expect, it, test } from 'vitest';
 import type { AnnotationFilter, AnnotationScript, IsNA, NotFilter, NumericalComparisonFilter, PatternFilter, ValueRank } from './filter';

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'>;