@platforma-sdk/model 1.20.27 → 1.21.10

package/dist/version.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/model",
-  "version": "1.20.27",
+  "version": "1.21.10",
   "description": "Platforma.bio SDK / Block Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

package/src/components/PFrameForGraphs.test.ts

@@ -0,0 +1,141 @@
+import {test, expect, describe} from '@jest/globals';
+import {getAdditionalColumns} from './PFrameForGraphs';
+import {PColumn, PColumnSpec, PColumnValues, PObjectId} from "@milaboratories/pl-model-common";
+import {TreeNodeAccessor} from "../render";
+
+
+describe('PFrameForGraph', () => {
+    test('columns are compatible, no additional columns', () => {
+        const columnSpec1:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {}},
+                {type: 'Int', name: 'axis2', domain: {}}
+            ]
+        }
+        const columnSpec2:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
+        }
+        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [{
+            id: 'id1' as PObjectId,
+            spec: columnSpec1,
+            data: []
+        }, {
+            id: 'id2' as PObjectId,
+            spec: columnSpec2,
+            data: []
+        }
+        ] as PColumn<PColumnValues>[]
+
+        expect(getAdditionalColumns(columns).length).toEqual(0);
+    });
+
+    test('columns are not compatible, 1 additional column', () => {
+        const columnSpec1:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+        }
+        const columnSpec2:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
+        }
+        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
+        ] as PColumn<PColumnValues>[]
+
+        const additionalColumns = getAdditionalColumns(columns);
+        expect(additionalColumns.length).toEqual(1);
+        expect(additionalColumns[0].id === columns[0].id).toEqual(false);
+        expect(additionalColumns[0].id === columns[1].id).toEqual(false);
+        expect(additionalColumns[0].spec).toEqual({
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+        });
+    });
+    test('columns are not compatible, additional columns are impossible', () => {
+        const columnSpec1:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+        }
+        const columnSpec2:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key2: 'b'}}]
+        }
+        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
+        ] as PColumn<PColumnValues>[]
+
+        const additionalColumns = getAdditionalColumns(columns);
+        expect(additionalColumns.length).toEqual(0);
+    });
+    test('columns are not compatible, 2 additional columns', () => {
+        const columnSpec1:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {key1: 'a'}},
+                {type: 'String', name: 'axis1', domain: {key1: 'b'}},
+            ]
+        }
+        const columnSpec2:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
+        }
+        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
+        ] as PColumn<PColumnValues>[]
+
+        const additionalColumns = getAdditionalColumns(columns);
+        expect(additionalColumns.length).toEqual(2);
+    });
+    test('columns are not compatible, 4 additional columns - by 2 axes', () => {
+        const columnSpec1:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {key1: 'a'}},
+                {type: 'String', name: 'axis1', domain: {key1: 'b'}},
+                {type: 'String', name: 'axis2', domain: {key1: 'a'}},
+                {type: 'String', name: 'axis2', domain: {key1: 'b'}},
+            ]
+        }
+        const columnSpec2:PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column2',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {}},
+                {type: 'String', name: 'axis2', domain: {}}
+            ]
+        }
+        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
+        ] as PColumn<PColumnValues>[]
+
+        const additionalColumns = getAdditionalColumns(columns);
+        expect(additionalColumns.length).toEqual(4);
+    });
+})

package/src/components/PFrameForGraphs.ts

@@ -0,0 +1,112 @@
+import {
+    AxisId,
+    getAxisId,
+    matchAxisId,
+    PColumn,
+    PColumnValues, PFrameHandle,
+    PObjectId,
+} from '@milaboratories/pl-model-common';
+import { RenderCtx, TreeNodeAccessor } from '../render';
+
+/** Create id for column copy with added keys in axes domains */
+const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
+    let wid = id.toString();
+    domains?.forEach(domain => {
+        if (domain) {
+            for (const [k, v] of Object.entries(domain)) {
+                wid += k;
+                wid += v;
+            }
+        }
+    });
+    return wid;
+};
+
+/** All combinations with 1 key from each list */
+function getKeysCombinations(idsLists: AxisId[][]) {
+    if (!idsLists.length) {
+        return [];
+    }
+    let result: AxisId[][] = [[]];
+    idsLists.forEach(list => {
+        const nextResult: AxisId[][] = [];
+        list.forEach(key => {
+            nextResult.push(...result.map(resultItem => [...resultItem, key]));
+        });
+        result = nextResult;
+    });
+    return result;
+}
+
+/** Main column can have additional domains, if secondary column (meta-column) has all axes match main column axes
+we can add its copy with missed domain fields for compatibility */
+function getAdditionalColumnsForPair(
+    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+): PColumn<TreeNodeAccessor | PColumnValues>[] {
+    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+
+    const isFullCompatible = secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id) && matchAxisId(id, mainId)));
+    if (isFullCompatible) { // in this case it isn't necessary to add more columns
+        return [];
+    }
+    const isCompatible = secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id)));
+    if (!isCompatible) { // in this case it is impossible to add some compatible column
+        return [];
+    }
+    // options with different possible domains for every axis of secondary column
+    const secondaryIdsOptions = secondaryAxesIds.map(id => {
+        return mainAxesIds.filter(mainId => matchAxisId(mainId, id));
+    });
+    // all possible combinations of axes with added domains
+    const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
+
+    return secondaryIdsVariants.map(idsList => {
+        const id = colId(secondaryColumn.id, idsList.map(id => id.domain));
+        return {
+            id: id as PObjectId,
+            spec: {
+                ...secondaryColumn.spec,
+                axesSpec: idsList.map((axisId, idx) => ({
+                    ...axisId,
+                    annotations: secondaryColumn.spec.axesSpec[idx].annotations
+                }))
+            },
+            data: secondaryColumn.data
+        };
+    });
+}
+
+export function getAdditionalColumns(columns: PColumn<TreeNodeAccessor | PColumnValues>[]):PColumn<TreeNodeAccessor | PColumnValues>[] {
+    const additionalColumns: PColumn<TreeNodeAccessor | PColumnValues>[] = [];
+    for (let i = 0; i < columns.length; i++) {
+        for (let j = i + 1; j < columns.length; j++) {
+            const column1 = columns[i];
+            const column2 = columns[j];
+
+            // check if column 1 is meta for column 2 or backward
+            additionalColumns.push(
+                ...getAdditionalColumnsForPair(column1, column2),
+                ...getAdditionalColumnsForPair(column2, column1)
+            );
+        }
+    }
+    return additionalColumns;
+}
+
+export function createPFrameForGraphs<A, U>(
+    ctx: RenderCtx<A, U>,
+    columns: PColumn<TreeNodeAccessor | PColumnValues>[]
+): PFrameHandle | undefined {
+    const extendedColumns = [...columns, ...getAdditionalColumns(columns)];
+    // if at least one column is not yet ready, we can't show the table
+    if (
+        extendedColumns.some(
+            (a) => a.data instanceof TreeNodeAccessor && !a.data.getIsReadyOrError()
+        )
+    )
+        return undefined;
+
+    return ctx.createPFrame(extendedColumns);
+}

package/src/components/PlDataTable.ts

@@ -6,6 +6,7 @@ import {
   matchAxisId,
   PColumn,
   PColumnIdAndSpec,
+  PColumnSpec,
   PColumnValues,
   PObjectId,
   PTableHandle,
@@ -282,6 +283,31 @@ export type PlTableFiltersModel = {
   filters?: PTableRecordFilter[];
 };
 
+export type CreatePlDataTableOps = {
+  /** Table filters, should contain */
+  filters?: PTableRecordFilter[];
+
+  /**
+   * Selects columns for which will be inner-joined to the table.
+   *
+   * Default behaviour: all columns are considered to be core
+   */
+  coreColumnPredicate?: (spec: PColumnSpec) => boolean;
+
+  /**
+   * Determines how core columns should be joined together:
+   *   inner - so user will only see records present in all core columns
+   *   full - so user will only see records present in any of the core columns
+   *
+   * All non-core columns will be left joined to the table produced by the core
+   * columns, in other words records form the pool of non-core columns will only
+   * make their way into the final table if core table contins corresponding key.
+   *
+   * Default: 'full'
+   */
+  coreJoinType?: 'inner' | 'full';
+};
+
 /**
  * Create p-table handle given ui table state
  *
@@ -293,9 +319,32 @@ export type PlTableFiltersModel = {
 export function createPlDataTable<A, U>(
   ctx: RenderCtx<A, U>,
   columns: PColumn<TreeNodeAccessor | PColumnValues>[],
-  tableState?: PlDataTableState,
-  filters?: PTableRecordFilter[]
+  tableState: PlDataTableState | undefined
+): PTableHandle | undefined;
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues>[],
+  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>[],
+  tableState: PlDataTableState | undefined,
+  filters: PTableRecordFilter[]
+): PTableHandle | undefined;
+export function createPlDataTable<A, U>(
+  ctx: RenderCtx<A, U>,
+  columns: PColumn<TreeNodeAccessor | PColumnValues>[],
+  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 allLabelCols = ctx.resultPool
     .getData()
     .entries.map((d) => d.obj)
@@ -351,16 +400,28 @@ export function createPlDataTable<A, U>(
   )
     return undefined;
 
+  let coreColumns = columns;
+  const secondaryColumns: typeof columns = [];
+
+  if (ops?.coreColumnPredicate) {
+    coreColumns = [];
+    for (const c of columns)
+      if (ops.coreColumnPredicate(c.spec)) coreColumns.push(c);
+      else secondaryColumns.push(c);
+  }
+
+  secondaryColumns.push(...labelColumns.values());
+
   return ctx.createPTable({
     src: {
       type: 'outer',
       primary: {
-        type: 'full',
-        entries: columns.map((c) => ({ type: 'column', column: c }))
+        type: ops?.coreJoinType ?? 'full',
+        entries: coreColumns.map((c) => ({ type: 'column', column: c }))
       },
-      secondary: [...labelColumns.values()].map((c) => ({ type: 'column', column: c }))
+      secondary: secondaryColumns.map((c) => ({ type: 'column', column: c }))
     },
-    filters: [...(tableState?.pTableParams?.filters ?? []), ...(filters ?? [])],
+    filters: [...(ops?.filters ?? []), ...(tableState?.pTableParams?.filters ?? [])],
     sorting: tableState?.pTableParams?.sorting ?? []
   });
 }

package/src/components/index.ts

@@ -1 +1,2 @@
 export * from './PlDataTable';
+export * from './PFrameForGraphs';