@platforma-sdk/model 1.21.0 → 1.21.10

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PlatformaSDKVersion = "1.21.0";
+export declare const PlatformaSDKVersion = "1.21.10";
 //# 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.21.0",
+  "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/index.ts

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