@milaboratories/pl-model-common 1.19.5 → 1.19.6

package/dist/json.d.ts

@@ -3,14 +3,14 @@ type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
 };
 type NotAssignableToJson = bigint | symbol | Function;
-export type JsonCompatible<T> = unknown extends T ? never : {
+export type JsonCompatible<T> = unknown extends T ? unknown : {
     [P in keyof T]: T[P] extends JsonValue ? T[P] : T[P] extends NotAssignableToJson ? never : JsonCompatible<T[P]>;
 };
-export type StringifiedJson<T> = JsonCompatible<T> extends never ? never : string & {
+export type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
     __json_stringified: T;
 };
 export declare function stringifyJson<T>(value: JsonCompatible<T>): StringifiedJson<T>;
-export type CanonicalizedJson<T> = JsonCompatible<T> extends never ? never : string & {
+export type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
     __json_canonicalized: T;
 };
 export declare function canonicalizeJson<T>(value: JsonCompatible<T>): CanonicalizedJson<T>;

package/dist/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAEA,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAElE,KAAK,SAAS,GAAG,aAAa,GAAG,SAAS,EAAE,GAAG;IAC7C,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAGF,KAAK,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,OAAO,SAAS,CAAC,GAAG,KAAK,GAAG;KACzD,CAAC,IAAI,MAAM,CAAC,GACb,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,GAC3B,CAAC,CAAC,CAAC,CAAC,SAAS,mBAAmB,GAAG,KAAK,GACtC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG;IAClF,kBAAkB,EAAE,CAAC,CAAC;CACvB,CAAC;AAEF,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAE7E;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG;IACpF,oBAAoB,EAAE,CAAC,CAAC;CACzB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAElF;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAEhF"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAEA,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAElE,KAAK,SAAS,GAAG,aAAa,GAAG,SAAS,EAAE,GAAG;IAC7C,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAGF,KAAK,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,OAAO,SAAS,CAAC,GAAG,OAAO,GAAG;KAC3D,CAAC,IAAI,MAAM,CAAC,GACb,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,GAC3B,CAAC,CAAC,CAAC,CAAC,SAAS,mBAAmB,GAAG,KAAK,GACtC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG;IAC5F,kBAAkB,EAAE,CAAC,CAAC;CACvB,CAAC;AAEF,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAE7E;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG;IAC9F,oBAAoB,EAAE,CAAC,CAAC;CACzB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAElF;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAEhF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.19.5",
+  "version": "1.19.6",
   "description": "Platforma SDK Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

package/src/drivers/pframe/data_types.ts

@@ -1,8 +1,5 @@
 import type { Branded } from '../../branding';
-import {
-  type ValueType,
-  type ValueTypeBytes,
-} from './spec/spec';
+import { ValueType } from './spec/spec';
 
 export type PVectorDataInt = Int32Array;
 export type PVectorDataLong = BigInt64Array;
@@ -11,12 +8,12 @@ export type PVectorDataDouble = Float64Array;
 export type PVectorDataString = (null | string)[];
 export type PVectorDataBytes = (null | Uint8Array)[];
 export type PVectorDataTyped<DataType extends ValueType> =
-  DataType extends 'Int' ? PVectorDataInt :
-    DataType extends 'Long' ? PVectorDataLong :
-      DataType extends 'Float' ? PVectorDataFloat :
-        DataType extends 'Double' ? PVectorDataDouble :
-          DataType extends 'String' ? PVectorDataString :
-            DataType extends 'Bytes' ? PVectorDataBytes :
+  DataType extends typeof ValueType.Int ? PVectorDataInt :
+    DataType extends typeof ValueType.Long ? PVectorDataLong :
+      DataType extends typeof ValueType.Float ? PVectorDataFloat :
+        DataType extends typeof ValueType.Double ? PVectorDataDouble :
+          DataType extends typeof ValueType.String ? PVectorDataString :
+            DataType extends typeof ValueType.Bytes ? PVectorDataBytes :
               never;
 export type PVectorData = PVectorDataTyped<ValueType>;
 
@@ -62,17 +59,17 @@ function isValueNA(vector: PTableVector, row: number): boolean {
   const valueType = vector.type;
   const value = vector.data[row];
   switch (valueType) {
-    case 'Int':
+    case ValueType.Int:
       return (value as PVectorDataInt[number]) === -2147483648;
-    case 'Long':
+    case ValueType.Long:
       return (value as PVectorDataLong[number]) === -9007199254740991n;
-    case 'Float':
+    case ValueType.Float:
       return Number.isNaN((value as PVectorDataFloat[number]));
-    case 'Double':
+    case ValueType.Double:
       return Number.isNaN((value as PVectorDataDouble[number]));
-    case 'String':
+    case ValueType.String:
       return (value as PVectorDataString[number]) === null;
-    case 'Bytes':
+    case ValueType.Bytes:
       return (value as PVectorDataBytes[number]) === null;
     default:
       throw Error(`unsupported data type: ${valueType satisfies never}`);
@@ -95,7 +92,7 @@ export function isPTableNA(value: unknown): value is PTableNA {
   return value === PTableNA;
 }
 
-export type ValueTypeSupported = Exclude<ValueType, ValueTypeBytes>;
+export type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;
 
 export type PTableValueInt = number;
 export type PTableValueLong = number;
@@ -103,11 +100,11 @@ export type PTableValueFloat = number;
 export type PTableValueDouble = number;
 export type PTableValueString = string;
 export type PTableValueData<DataType extends ValueTypeSupported> =
-  DataType extends 'Int' ? PTableValueInt :
-    DataType extends 'Long' ? PTableValueLong :
-      DataType extends 'Float' ? PTableValueFloat :
-        DataType extends 'Double' ? PTableValueDouble :
-          DataType extends 'String' ? PTableValueString :
+  DataType extends typeof ValueType.Int ? PTableValueInt :
+    DataType extends typeof ValueType.Long ? PTableValueLong :
+      DataType extends typeof ValueType.Float ? PTableValueFloat :
+        DataType extends typeof ValueType.Double ? PTableValueDouble :
+          DataType extends typeof ValueType.String ? PTableValueString :
             never;
 export type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
 export type PTableValue<
@@ -157,8 +154,8 @@ function pTableValueImpl<
     dataType?: DataType;
   },
 ) {
-  const valueType: ValueType = column.type;
-  if (valueType === 'Bytes') {
+  const valueType = column.type;
+  if (valueType === ValueType.Bytes) {
     throw Error('Bytes not yet supported');
   }
 
@@ -176,15 +173,15 @@ function pTableValueImpl<
 
   const value = column.data[row]!;
   switch (valueType) {
-    case 'Int':
+    case ValueType.Int:
       return value as PVectorDataInt[number];
-    case 'Long':
+    case ValueType.Long:
       return Number(value as PVectorDataLong[number]);
-    case 'Float':
+    case ValueType.Float:
       return value as PVectorDataFloat[number];
-    case 'Double':
+    case ValueType.Double:
       return value as PVectorDataDouble[number];
-    case 'String':
+    case ValueType.String:
       return (value as PVectorDataString[number])!;
   }
 }

package/src/drivers/pframe/index.ts

@@ -12,3 +12,5 @@ export * from './unique_values';
 export * from './spec';
 
 export * from './driver';
+
+export * from './linker_columns';

package/src/drivers/pframe/linker_columns.test.ts

@@ -0,0 +1,238 @@
+import {
+    Annotation,
+    AxisSpec,
+    AxisSpecNormalized,
+    getArrayFromAxisTree,
+    getAxesTree,
+    getNormalizedAxesList,
+    getSetFromAxisTree,
+    PColumnIdAndSpec,
+    ValueType,
+} from './spec/index';
+import { PObjectId } from '../../pool';
+import { stringifyJson } from '../../json'
+import {
+    describe,
+    expect,
+    test,
+} from 'vitest';
+import { LinkerMap } from './linker_columns';
+
+function makeTestAxis(params: {
+    name: string;
+    parents?: AxisSpec[];
+}): AxisSpec {
+    return {
+        type: ValueType.Int,
+        name: params.name,
+        annotations: {
+            [Annotation.Label]: `${params.name} axis`,
+            ...(params.parents && params.parents.length > 0
+                ? { [Annotation.Parents]: stringifyJson(params.parents) }
+                : {}
+            ),
+        } satisfies Annotation,
+    };
+}
+
+function makeLinkerColumn(params: {
+    name: string;
+    from: AxisSpec[];
+    to: AxisSpec[];
+}): PColumnIdAndSpec {
+    return {
+        columnId: params.name as PObjectId,
+        spec: {
+            kind: 'PColumn',
+            valueType: ValueType.String,
+            name: params.name,
+            axesSpec: [...params.from, ...params.to],
+            annotations: {
+                [Annotation.Label]: `${params.name} column`,
+                [Annotation.IsLinkerColumn]: stringifyJson(true),
+            } satisfies Annotation,
+        },
+    };
+}
+
+/** Returns all permutations of initial array */
+function allPermutations<T>(arr: T[]): T[][] {
+    switch (arr.length) {
+        case 0: return [];
+        case 1: return [arr];
+        case 2: return [arr, [arr[1], arr[0]]];
+        default: return arr.reduce(
+            (acc, item, i) => acc.concat(
+                allPermutations<T>([...arr.slice(0, i), ...arr.slice(i + 1)])
+                    .map(val => [item, ...val])
+            ),
+            [] as T[][],
+        );
+    }
+};
+
+describe('Linker columns', () => {
+    test('Search in linker columns map', () => {
+        const [axis1, axis2, axis3, axis4, axis5] = getNormalizedAxesList([
+            makeTestAxis({ name: 'id1' }),
+            makeTestAxis({ name: 'id2' }),
+            makeTestAxis({ name: 'id3' }),
+            makeTestAxis({ name: 'id4' }),
+            makeTestAxis({ name: 'id5' })
+        ]);
+        const linkerMap = LinkerMap.fromColumns([
+            makeLinkerColumn({ name: 'c12', from: [axis1], to: [axis2] }),
+            makeLinkerColumn({ name: 'c13', from: [axis1], to: [axis3] }),
+            makeLinkerColumn({ name: 'c45', from: [axis4], to: [axis5] }),
+        ]);
+
+        let testCase = (params: {
+            from: AxisSpecNormalized[];
+            to: AxisSpecNormalized[];
+            expected: string[];
+        }) => {
+            const linkers = linkerMap.getLinkerColumnsForAxes({
+                from: params.from,
+                to: params.to,
+                throwWhenNoLinkExists: false,
+            });
+            expect(linkers.map(item => item.spec.name).sort()).toEqual(params.expected);
+        }
+
+        testCase({ from: [axis2], to: [axis3], expected: ['c12', 'c13'] });
+        testCase({ from: [axis1], to: [axis2], expected: ['c12'] });
+        testCase({ from: [axis1], to: [axis4], expected: []});
+    });
+
+    test('Axis tree - without parents', () => {
+        const [axisA, axisB] = getNormalizedAxesList([
+            makeTestAxis({ name: 'a' }),
+            makeTestAxis({ name: 'b' })
+        ]);
+        const tree = getAxesTree(axisA);
+        expect(getSetFromAxisTree(tree).size).toBe(1);
+        expect(getArrayFromAxisTree(tree).length).toBe(1);
+
+        expect(LinkerMap.getAxesGroups([axisA, axisB]).length).toBe(2);
+    })
+
+    test('Axis tree - with parents', () => {
+        const axisD = makeTestAxis({ name: 'd' });
+        const axisC = makeTestAxis({ name: 'c', parents: [axisD] });
+        const axisB = makeTestAxis({ name: 'b', parents: [axisC] });
+        const axisA = makeTestAxis({ name: 'a', parents: [axisB] });
+        const [axisDn, axisCn, axisBn, axisAn] = getNormalizedAxesList([axisD, axisC, axisB, axisA])
+
+        const tree = getAxesTree(axisAn);
+        expect(getSetFromAxisTree(tree).size).toBe(4);
+        expect(getArrayFromAxisTree(tree).length).toBe(4);
+
+        for (const group of allPermutations([axisAn, axisBn, axisCn, axisDn])) {
+            expect(LinkerMap.getAxesGroups(group).length).toBe(1);
+        }
+
+        const axisD2 = makeTestAxis({ name: 'd' });
+        const axisC2 = makeTestAxis({ name: 'c', parents: [axisD2] });
+        const axisB2 = makeTestAxis({ name: 'b' });
+        const axisA2 = makeTestAxis({ name: 'a', parents: [axisB2] });
+        const normalized2 = getNormalizedAxesList([axisD2, axisC2, axisB2, axisA2])
+
+        for (const group of allPermutations(normalized2)) {
+            expect(LinkerMap.getAxesGroups(group).length).toBe(2);
+        }
+
+        const axisD3 = makeTestAxis({ name: 'd' });
+        const axisC3 = makeTestAxis({ name: 'c' });
+        const axisB3 = makeTestAxis({ name: 'b' });
+        const axisA3 = makeTestAxis({ name: 'a', parents: [axisB3] });
+        const normalized3 = getNormalizedAxesList([axisD3, axisC3, axisB3, axisA3])
+
+        for (const group of allPermutations(normalized3)) {
+            expect(LinkerMap.getAxesGroups(group).length).toBe(3);
+        }
+
+        const axisD4 = makeTestAxis({ name: 'd' });
+        const axisC4 = makeTestAxis({ name: 'c' });
+        const axisB4 = makeTestAxis({ name: 'b' });
+        const axisA4 = makeTestAxis({ name: 'a' });
+        const normalized4 = getNormalizedAxesList([axisD4, axisC4, axisB4, axisA4])
+
+        for (const group of allPermutations(normalized4)) {
+            expect(LinkerMap.getAxesGroups(group).length).toBe(4);
+        }
+    })
+
+    test('Generate partial trees', () => {
+        // Axes graph of parents (A, E - roots, C, B, D - parents) in some column:
+        // A - C
+        //  \_ B _ D
+        // E/
+        //
+        // If the column is not a linker: trees to search linkers should be:
+        // 1 C
+        // 2 D
+        // 3 B - D
+        // 4 A - C
+        //    \_ B - D
+        // 5 E - B - D
+
+        // If the axes are in a linker: trees must be in the linkers map:
+
+        // 1 A - C
+        //    \_ B _ D
+        // 2 E - B - D
+
+        const axisD = makeTestAxis({ name: 'd' });
+        const axisC = makeTestAxis({ name: 'c' });
+        const axisB = makeTestAxis({ name: 'b', parents: [axisD] });
+        const axisA = makeTestAxis({ name: 'a', parents: [axisB, axisC] });
+        const axisE = makeTestAxis({ name: 'e', parents: [axisB, axisC] });
+        const axisF = makeTestAxis({ name: 'f' });
+        const axisH = makeTestAxis({ name: 'h' });
+
+        const group1 = [axisA, axisB, axisC, axisD, axisE];
+        const group2 = [axisF];
+        const group3 = [axisH];
+        const group1Normalized = getNormalizedAxesList(group1);
+        const group2Normalized = getNormalizedAxesList(group2);
+        const [axisAn, axisBn, axisCn, axisDn, axisEn] = group1Normalized;
+
+        const linker1 = makeLinkerColumn({ name: 'linker1', from: group1, to: group2 });
+        const linker2 = makeLinkerColumn({ name: 'linker2', from: group2, to: group3 });
+
+        const roots = LinkerMap.getAxesRoots(group1Normalized);
+
+        expect(roots).toEqual([axisAn, axisEn]);
+
+        const groups = LinkerMap.getAxesGroups([...group1Normalized, ...group2Normalized]);
+        expect(groups.length).toBe(2);
+        expect(groups[0]).toEqual(group1Normalized);
+        expect(groups[1]).toEqual(group2Normalized);
+
+        const linkersMap = LinkerMap.fromColumns([linker1, linker2]);
+
+        expect(
+            new Set(linkersMap.getReachableByLinkersAxesFromAxes(group2Normalized).map(a => a.name))
+        ).toEqual(
+            new Set(([...group1, ...group3]).map(a => a.name))
+        );
+        expect(linkersMap.getReachableByLinkersAxesFromAxes([axisDn])).toEqual([]);
+        expect(linkersMap.getReachableByLinkersAxesFromAxes([axisBn])).toEqual([]);
+    });
+
+    test('Order of parents should not matter', () => {
+        const axisA = makeTestAxis({ name: 'a' });
+        const axisB = makeTestAxis({ name: 'b' });
+        const axisC1 = makeTestAxis({ name: 'c', parents: [axisA, axisB] });
+        const axisC2 = makeTestAxis({ name: 'c', parents: [axisB, axisA] });
+        const axisD = makeTestAxis({ name: 'd' });
+
+        const [a, b, c1, c2, d] = getNormalizedAxesList([axisA, axisB, axisC1, axisC2, axisD]);
+        const linkerMap = LinkerMap.fromColumns([
+            makeLinkerColumn({ name: 'linker1', from: [axisA, axisB, axisC1], to: [axisD] })
+        ]);
+
+        expect(linkerMap.getReachableByLinkersAxesFromAxes([c2])).not.toHaveLength(0);
+        expect(linkerMap.getReachableByLinkersAxesFromAxes([c1])).not.toHaveLength(0);
+    })
+});

package/src/drivers/pframe/linker_columns.ts

@@ -0,0 +1,283 @@
+import {
+  canonicalizeJson,
+  parseJson,
+  type CanonicalizedJson,
+} from '../../json';
+import {
+  Annotation,
+  readAnnotationJson,
+  type AxisSpec,
+  type PColumnIdAndSpec,
+  type AxisSpecNormalized,
+  type AxisId,
+  getAxisId,
+  getNormalizedAxesList,
+  getArrayFromAxisTree,
+  getAxesTree,
+} from './spec/spec';
+
+type LinkerKey = CanonicalizedJson<AxisId[]>;
+export type CompositeLinkerMap = Map<
+  LinkerKey,
+  {
+    keyAxesSpec: AxisSpecNormalized[]; // axis specs - source for the key
+    linkWith: Map<LinkerKey, PColumnIdAndSpec>; // for every axis (possibly in group with parents - available by linkers another axes and corresponding linkers)
+  }
+>;
+
+interface LinkersData {
+  data: CompositeLinkerMap;
+}
+export class LinkerMap implements LinkersData {
+  /** Graph of linkers connected by axes (single or grouped by parents) */
+  readonly data: CompositeLinkerMap;
+
+  constructor(linkerMap: CompositeLinkerMap) {
+    this.data = linkerMap;
+  }
+
+  get keys() {
+    return this.data.keys();
+  }
+
+  get keyAxesIds() {
+    return [...this.data.keys()].map(parseJson);
+  }
+
+  static fromColumns(columns: PColumnIdAndSpec[]) {
+    const result: CompositeLinkerMap = new Map();
+    for (const linker of columns.filter((l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn))) {
+      const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec)); // split input axes into groups by parent links from annotation
+
+      if (groups.length !== 2) {
+        continue; // not a valid linker column
+      }
+      const [left, right] = groups;
+
+      // In case of group:
+      // A - C
+      //  \_ B _ D
+      // E/
+      // put 2 variants as keys:
+      // A - C
+      //  \_ B _ D
+      // and
+      // E - B - D
+      const leftKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(left).map((axis) => {
+        const axes = getArrayFromAxisTree(getAxesTree(axis));
+        const key = canonicalizeJson(axes.map(getAxisId));
+        return [key, axes];
+      });
+      const rightKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(right).map((axis) => {
+        const axes = getArrayFromAxisTree(getAxesTree(axis));
+        const key = canonicalizeJson(axes.map(getAxisId));
+        return [key, axes];
+      });
+
+      for (const [keyLeft, spec] of leftKeyVariants) {
+        if (!result.has(keyLeft)) {
+          result.set(keyLeft, { keyAxesSpec: spec, linkWith: new Map() });
+        }
+      }
+      for (const [keyRight, spec] of rightKeyVariants) {
+        if (!result.has(keyRight)) {
+          result.set(keyRight, { keyAxesSpec: spec, linkWith: new Map() });
+        }
+      }
+      for (const [keyLeft] of leftKeyVariants) {
+        for (const [keyRight] of rightKeyVariants) {
+          result.get(keyLeft)?.linkWith.set(keyRight, linker);
+          result.get(keyRight)?.linkWith.set(keyLeft, linker);
+        }
+      }
+    }
+    return new this(result);
+  }
+
+  /** Get all available nodes of linker graphs if start from sourceAxesKeys */
+  searchAvailableAxesKeys(sourceAxesKeys: LinkerKey[]): Set<LinkerKey> {
+    const startKeys = new Set(sourceAxesKeys);
+    const allAvailableKeys = new Set<LinkerKey>();
+    let nextKeys = sourceAxesKeys;
+    while (nextKeys.length) {
+      const next: LinkerKey[] = [];
+      for (const key of nextKeys) {
+        const node = this.data.get(key);
+        if (!node) continue;
+        for (const availableKey of node.linkWith.keys()) {
+          if (!allAvailableKeys.has(availableKey) && !startKeys.has(availableKey)) {
+            next.push(availableKey);
+            allAvailableKeys.add(availableKey);
+          }
+        }
+      }
+      nextKeys = next;
+    }
+    return allAvailableKeys;
+  }
+
+  /** Get all linker columns that are necessary to reach endKey from startKey */
+  searchLinkerPath(startKey: LinkerKey, endKey: LinkerKey): PColumnIdAndSpec[] {
+    const previous: Record<LinkerKey, LinkerKey> = {};
+    let nextIds = new Set([startKey]);
+    const visited = new Set([startKey]);
+    while (nextIds.size) {
+      const next = new Set<LinkerKey>();
+      for (const nextId of nextIds) {
+        const node = this.data.get(nextId);
+        if (!node) continue;
+        for (const availableId of node.linkWith.keys()) {
+          previous[availableId] = nextId;
+          if (availableId === endKey) {
+            const ids: LinkerKey[] = [];
+            let current = endKey;
+            while (previous[current] !== startKey) {
+              ids.push(current);
+              current = previous[current];
+            }
+            ids.push(current);
+            return ids.map((id: LinkerKey) => this.data.get(id)!.linkWith.get(previous[id])!);
+          } else if (!visited.has(availableId)) {
+            next.add(availableId);
+            visited.add(availableId);
+          }
+        }
+      }
+      nextIds = next;
+    }
+    return [];
+  }
+
+  getLinkerColumnsForAxes({
+    from: sourceAxes,
+    to: targetAxes,
+    throwWhenNoLinkExists = true,
+  }: {
+    from: AxisSpecNormalized[];
+    to: AxisSpecNormalized[];
+    throwWhenNoLinkExists?: boolean;
+  }): PColumnIdAndSpec[] {
+  // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)
+    const startKeys: LinkerKey[] = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+
+    return Array.from(
+      new Map(
+        LinkerMap.getAxesRoots(targetAxes)
+          .map(LinkerMap.getLinkerKeyFromAxisSpec) // target keys contain all axes to be linked; if some of target axes has parents they must be in the key
+          .flatMap((targetKey) => {
+            const linkers = startKeys
+              .map((startKey) => this.searchLinkerPath(startKey, targetKey))
+              .reduce((shortestPath, path) => shortestPath.length && shortestPath.length < path.length ? shortestPath : path,
+                [] as PColumnIdAndSpec[])
+              .map((linker) => [linker.columnId, linker] as const);
+            if (!linkers.length && throwWhenNoLinkExists) {
+              throw Error(`Unable to find linker column for ${targetKey}`);
+            }
+            return linkers;
+          }),
+      ).values(),
+    );
+  }
+
+  /** Get list of axisSpecs from keys of linker columns map  */
+  getAxesListFromKeysList(keys: LinkerKey[]): AxisSpecNormalized[] {
+    return Array.from(
+      new Map(
+        keys.flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
+          .map((axis) => [canonicalizeJson(getAxisId(axis)), axis]),
+      ).values(),
+    );
+  }
+
+  /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
+  getNonLinkableAxes(
+    sourceAxes: AxisSpecNormalized[],
+    targetAxes: AxisSpecNormalized[],
+  ): AxisSpecNormalized[] {
+    const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+    // target keys contain all axes to be linked; if some of target axes has parents they must be in the key
+    const missedTargetKeys = LinkerMap.getAxesRoots(targetAxes)
+      .map(LinkerMap.getLinkerKeyFromAxisSpec)
+      .filter((targetKey) =>
+        !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length),
+      );
+    return this.getAxesListFromKeysList(missedTargetKeys);
+  }
+
+  /** Get all axes that can be connected to sourceAxes by linkers */
+  getReachableByLinkersAxesFromAxes(sourceAxes: AxisSpecNormalized[]): AxisSpec[] {
+    const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+    const availableKeys = this.searchAvailableAxesKeys(startKeys);
+    return this.getAxesListFromKeysList([...availableKeys]);
+  }
+
+  static getLinkerKeyFromAxisSpec(axis: AxisSpecNormalized): LinkerKey {
+    return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+  }
+
+  /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.
+     There are no order inside every group. */
+  static getAxesGroups(axesSpec: AxisSpecNormalized[]): AxisSpecNormalized[][] {
+    switch (axesSpec.length) {
+      case 0: return [];
+      case 1: return [[axesSpec[0]]];
+      default: break;
+    }
+
+    const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
+    const axisParentsIdxs = axesSpec.map(
+      (spec) => new Set(
+        spec.parentAxesSpec
+          .map((spec) => canonicalizeJson(getAxisId(spec)))
+          .map((el) => {
+            const idx = axisKeys.indexOf(el);
+            if (idx === -1) {
+              throw new Error(`malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`);
+            }
+            return idx;
+          }),
+      ),
+    );
+
+    const allIdxs = [...axesSpec.keys()];
+    const groups: number[][] = []; // groups of axis indexes
+
+    const usedIdxs = new Set<number>();
+    let nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+    while (nextFreeEl !== undefined) {
+      const currentGroup = [nextFreeEl];
+      usedIdxs.add(nextFreeEl);
+
+      let nextElsOfCurrentGroup = [nextFreeEl];
+      while (nextElsOfCurrentGroup.length) {
+        const next = new Set<number>();
+        for (const groupIdx of nextElsOfCurrentGroup) {
+          const groupElementParents = axisParentsIdxs[groupIdx];
+          allIdxs.forEach((idx) => {
+            if (idx === groupIdx || usedIdxs.has(idx)) {
+              return;
+            }
+            const parents = axisParentsIdxs[idx];
+            if (parents.has(groupIdx) || groupElementParents.has(idx)) {
+              currentGroup.push(idx);
+              next.add(idx);
+              usedIdxs.add(idx);
+            }
+          });
+        }
+        nextElsOfCurrentGroup = [...next];
+      }
+
+      groups.push([...currentGroup]);
+      nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+    };
+
+    return groups.map((group) => group.map((idx) => axesSpec[idx]));
+  }
+
+  /** Get all axes that are not parents of any other axis */
+  static getAxesRoots(axes: AxisSpecNormalized[]): AxisSpecNormalized[] {
+    const parentsSet = new Set(axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))));
+    return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));
+  }
+}