@platforma-sdk/model 1.29.2 → 1.29.13

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PlatformaSDKVersion = "1.29.2";
+export declare const PlatformaSDKVersion = "1.29.13";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,WAAW,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/model",
-  "version": "1.29.2",
+  "version": "1.29.13",
   "description": "Platforma.bio SDK / Block Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
     "utility-types": "^3.11.0",
     "canonicalize": "~2.1.0",
     "zod": "~3.23.8",
-    "@milaboratories/pl-model-common": "^1.13.5",
+    "@milaboratories/pl-model-common": "^1.13.7",
     "@milaboratories/pl-error-like": "^1.12.0"
   },
   "devDependencies": {
@@ -31,8 +31,8 @@
     "jest": "^29.7.0",
     "@jest/globals": "^29.7.0",
     "ts-jest": "^29.2.6",
-    "@platforma-sdk/eslint-config": "1.0.3",
-    "@milaboratories/platforma-build-configs": "1.0.3"
+    "@milaboratories/platforma-build-configs": "1.0.3",
+    "@platforma-sdk/eslint-config": "1.0.3"
   },
   "scripts": {
     "type-check": "node ./scripts/save-package-version.cjs && tsc --noEmit --composite false",

package/src/components/PFrameForGraphs.test.ts

@@ -187,6 +187,43 @@ describe('PFrameForGraph', () => {
         expect(enrichedColumns.map((c) => c.id)).toEqual(['id1', 'id2', 'id3'])
     })
 
+    test('enrichColumnsWithCompatibleMetadata doesn\'t add column with identical spec', () => {
+        const columnSpec1: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {key1: 'a'}},
+                {type: 'String', name: 'axis2', domain: {key1: 'b'}},
+            ]
+        };
+        const metaColumnSpec1: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'metadata1',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1'}]
+        };
+        const metaColumnSpec2: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'metadata2',
+            valueType: 'String',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+        };
+
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+        ] as PColumn<PColumnValues>[];
+        const upstream: PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id2' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id3' as PObjectId, spec: metaColumnSpec1, data: []},
+            {id: 'id4' as PObjectId, spec: metaColumnSpec2, data: []},
+        ] as PColumn<PColumnValues>[];
+
+        const enrichedColumns = enrichColumnsWithCompatible(columns, upstream);
+        expect(enrichedColumns.map((c) => c.id)).toEqual(['id1', 'id3', 'id4'])
+    })
+
+
     test('Labels of added columns include added domains, but not include common domains', () => {
         const columnSpec1: PColumnSpec = {
             kind: 'PColumn',

package/src/components/PFrameForGraphs.ts

@@ -1,12 +1,16 @@
 import type {
   AxisId,
+  CanonicalizedJson,
   PColumn,
+  PColumnSpecId,
   PColumnValues,
   PFrameHandle,
   PObjectId,
   ValueType } from '@milaboratories/pl-model-common';
 import {
+  canonicalizeJson,
   getAxisId,
+  getPColumnSpecId,
   isPColumn,
   matchAxisId,
 } from '@milaboratories/pl-model-common';
@@ -172,19 +176,29 @@ export function enrichColumnsWithCompatible(
   mainColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
   secondaryColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
 ): PColumn<TreeNodeAccessor | PColumnValues>[] {
-  const result = [...mainColumns];
+  const mainColumnsIds = new Set<PObjectId>();
+  const mainColumnsBySpec = new Map<CanonicalizedJson<PColumnSpecId>, typeof mainColumns[number]>();
+  mainColumns.forEach((column) => {
+    mainColumnsIds.add(column.id);
+    mainColumnsBySpec.set(canonicalizeJson(getPColumnSpecId(column.spec)), column);
+  });
+
+  const secondaryColumnsBySpec = new Map<CanonicalizedJson<PColumnSpecId>, typeof secondaryColumns[number]>();
   for (const secondaryColumn of secondaryColumns) {
-    for (const mainColumn of mainColumns) {
-      if (mainColumn.id === secondaryColumn.id) {
-        break;
-      }
+    if (mainColumnsIds.has(secondaryColumn.id)) continue;
+
+    const spec = canonicalizeJson(getPColumnSpecId(secondaryColumn.spec));
+    if (mainColumnsBySpec.has(spec)) continue;
+
+    for (const mainColumn of mainColumnsBySpec.values()) {
       if (checkCompatibility(mainColumn, secondaryColumn)) {
-        result.push(secondaryColumn);
+        secondaryColumnsBySpec.set(spec, secondaryColumn);
         break;
       }
     }
   }
-  return result;
+
+  return [...mainColumnsBySpec.values(), ...secondaryColumnsBySpec.values()];
 }
 
 const VALUE_TYPES: ValueType[] = [

package/src/components/PlDataTable.ts

@@ -1,5 +1,6 @@
 import type {
   AxisSpec,
+  CanonicalizedJson,
   DataInfo,
   JoinEntry,
   PColumn,
@@ -7,17 +8,39 @@ import type {
   PColumnSpec,
   PColumnValues,
   PObjectId,
+  PTableColumnIdColumn,
+  PTableColumnSpec,
+  PTableDef,
   PTableHandle,
   PTableRecordFilter,
+  PTableRecordSingleValueFilterV2,
   PTableSorting,
 } from '@milaboratories/pl-model-common';
-import {
-  getAxisId,
-  isPColumn,
-  matchAxisId,
-} from '@milaboratories/pl-model-common';
-import type { RenderCtx } from '../render';
-import { TreeNodeAccessor } from '../render';
+import { canonicalizeJson, getAxisId, getColumnIdAndSpec, matchAxisId } from '@milaboratories/pl-model-common';
+import type { AxisLabelProvider, ColumnProvider, RenderCtx } from '../render';
+import { PColumnCollection, TreeNodeAccessor } from '../render';
+
+/** Canonicalized PTableColumnSpec JSON string */
+export type PTableColumnSpecJson = CanonicalizedJson<PTableColumnSpec>;
+
+/** Encode `PTableColumnId` as canonicalized JSON string */
+export function strinfigyPTableColumnId(spec: PTableColumnSpec): PTableColumnSpecJson {
+  const type = spec.type;
+  switch (type) {
+    case 'axis':
+      return canonicalizeJson(spec);
+    case 'column':
+      return canonicalizeJson(spec);
+    default:
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      throw Error(`unsupported column type: ${type satisfies never}`);
+  }
+}
+
+/** Parse `PTableColumnId` from JSON string */
+export function parsePTableColumnId(str: PTableColumnSpecJson): PTableColumnSpec {
+  return JSON.parse(str) as PTableColumnSpec;
+}
 
 /** Data table state */
 export type PlDataTableGridState = {
@@ -44,7 +67,7 @@ export type PlDataTableGridState = {
   /** Includes column visibility */
   columnVisibility?: {
     /** All colIds which were hidden */
-    hiddenColIds: string[];
+    hiddenColIds: PTableColumnSpecJson[];
   };
   /** current sheet selections */
   sheets?: Record<string, string | number>;
@@ -319,49 +342,29 @@ export type CreatePlDataTableOps = {
   coreJoinType?: 'inner' | 'full';
 };
 
-/**
- * Create p-table handle given ui table state
- *
- * @param ctx context
- * @param columns column list
- * @param tableState table ui state
- * @returns
- */
-export function createPlDataTable<A, U>(
-  ctx: RenderCtx<A, U>,
-  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
-  tableState: PlDataTableState | undefined
-): PTableHandle | undefined;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtx<A, U>,
-  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
-  tableState: PlDataTableState | undefined,
-  ops: CreatePlDataTableOps
-): PTableHandle | undefined;
-/** @deprecated use method with extended ops as the last argument */
-export function createPlDataTable<A, U>(
-  ctx: RenderCtx<A, U>,
-  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
-  tableState: PlDataTableState | undefined,
-  filters: PTableRecordFilter[]
-): PTableHandle | undefined;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtx<A, U>,
-  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
-  tableState: PlDataTableState | undefined,
-  ops?: PTableRecordFilter[] | CreatePlDataTableOps,
-): PTableHandle | undefined {
-  // ops migration for backward compatibility with previous deprecated API
-  if (Array.isArray(ops)) {
-    ops = { filters: ops };
-  }
+/** Check if column is a label column */
+export function isLabelColumn(column: PColumnSpec) {
+  return column.axesSpec.length === 1 && column.name === 'pl7.app/label';
+}
 
-  const allLabelCols = ctx.resultPool
-    .getData()
-    .entries.map((d) => d.obj)
-    .filter(isPColumn)
-    .filter((p) => p.spec.name === 'pl7.app/label' && p.spec.axesSpec.length === 1);
+/** Get all label columns from the result pool */
+export function getAllLabelColumns(
+  resultPool: AxisLabelProvider & ColumnProvider,
+): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] | undefined {
+  return new PColumnCollection()
+    .addAxisLabelProvider(resultPool)
+    .addColumnProvider(resultPool)
+    .getColumns({
+      name: 'pl7.app/label',
+      axes: [{}], // exactly one axis
+    }, { dontWaitAllData: true });
+}
 
+/** Get label columns matching the provided columns from the result pool */
+export function getMatchingLabelColumns(
+  columns: PColumnIdAndSpec[],
+  allLabelColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[],
+): PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[] {
   const colId = (id: PObjectId, domain?: Record<string, string>) => {
     let wid = id.toString();
     if (domain) {
@@ -373,12 +376,11 @@ export function createPlDataTable<A, U>(
     return wid;
   };
 
-  const labelColumns = new Map<string, PColumn<TreeNodeAccessor>>();
-
+  const labelColumns = new Map<string, typeof allLabelColumns[number]>();
   for (const col of columns) {
     for (const axis of col.spec.axesSpec) {
       const axisId = getAxisId(axis);
-      for (const labelColumn of allLabelCols) {
+      for (const labelColumn of allLabelColumns) {
         const labelAxis = labelColumn.spec.axesSpec[0];
         const labelAxisId = getAxisId(labelColumn.spec.axesSpec[0]);
         if (matchAxisId(axisId, labelAxisId)) {
@@ -403,38 +405,219 @@ export function createPlDataTable<A, U>(
     }
   }
 
-  // if at least one column is not yet ready, we can't show the table
-  if (
-    [...columns, ...labelColumns.values()].some(
-      (a) => a.data instanceof TreeNodeAccessor && !a.data.getIsReadyOrError(),
-    )
-  )
-    return undefined;
+  return [...labelColumns.values()];
+}
 
+/** 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());
+        }
+      } else {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        throw Error(`unsupported column data type: ${d satisfies never}`);
+      }
+    });
+}
+
+function createPTableDef(
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  labelColumns: PColumn<TreeNodeAccessor | DataInfo<TreeNodeAccessor>>[],
+  coreJoinType: 'inner' | 'full',
+  filters: PTableRecordSingleValueFilterV2[],
+  sorting: PTableSorting[],
+  coreColumnPredicate?: ((spec: PColumnSpec) => boolean),
+): PTableDef<PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>> {
   let coreColumns = columns;
   const secondaryColumns: typeof columns = [];
 
-  if (ops?.coreColumnPredicate) {
+  if (coreColumnPredicate) {
     coreColumns = [];
     for (const c of columns)
-      if (ops.coreColumnPredicate(c.spec)) coreColumns.push(c);
+      if (coreColumnPredicate(c.spec)) coreColumns.push(c);
       else secondaryColumns.push(c);
   }
 
-  secondaryColumns.push(...labelColumns.values());
+  secondaryColumns.push(...labelColumns);
 
-  return ctx.createPTable({
+  return {
     src: {
       type: 'outer',
       primary: {
-        type: ops?.coreJoinType ?? 'full',
+        type: coreJoinType,
         entries: coreColumns.map((c) => ({ type: 'column', column: c })),
       },
       secondary: secondaryColumns.map((c) => ({ type: 'column', column: c })),
     },
-    filters: [...(ops?.filters ?? []), ...(tableState?.pTableParams?.filters ?? [])],
-    sorting: tableState?.pTableParams?.sorting ?? [],
-  });
+    filters,
+    sorting,
+  };
+}
+
+/**
+ * Create p-table handle given ui table state
+ *
+ * @param ctx context
+ * @param columns column list
+ * @param tableState table ui state
+ * @returns PlAgDataTable table source
+ */
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  tableState: PlDataTableState | undefined
+): PTableHandle | undefined;
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  tableState: PlDataTableState | undefined,
+  ops: CreatePlDataTableOps
+): PTableHandle | undefined;
+/** @deprecated use method with extended ops as the last argument */
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  tableState: PlDataTableState | undefined,
+  filters: PTableRecordFilter[]
+): PTableHandle | undefined;
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  tableState: PlDataTableState | undefined,
+  ops?: PTableRecordFilter[] | CreatePlDataTableOps,
+): PTableHandle | undefined {
+  // ops migration for backward compatibility with previous deprecated API
+  if (Array.isArray(ops)) {
+    ops = { filters: ops };
+  }
+
+  const coreJoinType = ops?.coreJoinType ?? 'full';
+  const filters: PTableRecordSingleValueFilterV2[]
+    = [...(ops?.filters ?? []), ...(tableState?.pTableParams?.filters ?? [])];
+  const sorting: PTableSorting[] = tableState?.pTableParams?.sorting ?? [];
+
+  const allLabelColumns = getAllLabelColumns(ctx.resultPool);
+  if (!allLabelColumns) return undefined;
+
+  const labelColumns = getMatchingLabelColumns(columns.map(getColumnIdAndSpec), allLabelColumns);
+
+  // if at least one column is not yet computed, we can't show the table
+  if (!allColumnsComputed([...columns, ...labelColumns])) return undefined;
+
+  return ctx.createPTable(
+    createPTableDef(columns, labelColumns, coreJoinType, filters, sorting, ops?.coreColumnPredicate));
+}
+
+/** PlAgDataTable model */
+export type PlDataTableModel = {
+  /** p-table specification (full, including hidden columns) */
+  tableSpec: PTableColumnSpec[];
+  /** p-table handle (integration of visible columns data) */
+  tableHandle: PTableHandle;
+};
+
+/** Check if column is hidden by default */
+export function isColumnOptional(spec: { annotations?: Record<string, string> }): boolean {
+  return spec.annotations?.['pl7.app/table/visibility'] === 'optional';
+}
+
+/**
+ * Create p-table spec and handle given ui table state
+ *
+ * @param ctx context
+ * @param columns column list
+ * @param tableState table ui state
+ * @returns PlAgDataTableV2 table source
+ */
+export function createPlDataTableV2<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues | DataInfo<TreeNodeAccessor>>[],
+  mainColumnPredicate: (spec: PColumnSpec) => boolean,
+  tableState: PlDataTableState | undefined,
+  ops?: CreatePlDataTableOps,
+): PlDataTableModel | undefined {
+  const coreJoinType = ops?.coreJoinType ?? 'full';
+  const filters: PTableRecordSingleValueFilterV2[]
+    = [...(ops?.filters ?? []), ...(tableState?.pTableParams?.filters ?? [])];
+  const sorting: PTableSorting[] = tableState?.pTableParams?.sorting ?? [];
+
+  const mainColumn = columns.find((c) => mainColumnPredicate(c.spec));
+  if (!mainColumn) return undefined;
+
+  const allLabelColumns = getAllLabelColumns(ctx.resultPool);
+  if (!allLabelColumns) return undefined;
+
+  const spec: PTableColumnSpec[] = [
+    ...mainColumn.spec.axesSpec.map((axis) => ({
+      type: 'axis',
+      id: getAxisId(axis),
+      spec: axis,
+    } satisfies PTableColumnSpec)),
+    ...[...columns, ...allLabelColumns].map((c) => ({
+      type: 'column',
+      id: c.id,
+      spec: c.spec,
+    } satisfies PTableColumnSpec)),
+  ];
+
+  const hiddenColumns = new Set<PObjectId>(((): PObjectId[] => {
+    // Inner join works as a filter - all columns must be present
+    if (coreJoinType === 'inner') return [];
+
+    const hiddenColIds = tableState?.gridState.columnVisibility?.hiddenColIds
+      ?.map(parsePTableColumnId)
+      .filter((c) => c.type === 'column')
+      .map((c) => c.id);
+    if (hiddenColIds) return hiddenColIds;
+
+    return columns
+      .filter((c) => isColumnOptional(c.spec))
+      .map((c) => c.id);
+  })());
+
+  // Main column must always be included in join to integrate all other columns
+  hiddenColumns.delete(mainColumn.id);
+  // Filters decrease the number of result rows, sorting changes the order of result rows
+  [...filters.map((f) => f.column), ...sorting.map((s) => s.column)]
+    .filter((c): c is PTableColumnIdColumn => c.type === 'column')
+    .map((c) => hiddenColumns.delete(c.id));
+
+  const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
+  const labelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
+
+  // if at least one column is not yet computed, we can't show the table
+  if (!allColumnsComputed([...visibleColumns, ...labelColumns])) return undefined;
+
+  const handle = ctx.createPTable(
+    createPTableDef(columns, labelColumns, coreJoinType, filters, sorting, ops?.coreColumnPredicate));
+
+  return {
+    tableSpec: spec,
+    tableHandle: handle,
+  } satisfies PlDataTableModel;
 }
 
 /** Create sheet entries for PlDataTable */