@milaboratories/pl-model-common 1.19.6 → 1.19.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.19.6",
+  "version": "1.19.7",
   "description": "Platforma SDK Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -26,8 +26,8 @@
     "typescript": "~5.6.3",
     "vite": "^6.3.5",
     "vitest": "^2.1.9",
-    "@platforma-sdk/eslint-config": "1.0.3",
-    "@milaboratories/build-configs": "1.0.5"
+    "@milaboratories/build-configs": "1.0.5",
+    "@platforma-sdk/eslint-config": "1.0.3"
   },
   "scripts": {
     "type-check": "tsc --noEmit --composite false",

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

@@ -104,6 +104,31 @@ describe('Linker columns', () => {
         testCase({ from: [axis1], to: [axis4], expected: []});
     });
 
+    test('Search in linker columns map with parents', () => {
+        const axisC = makeTestAxis({ name: 'c' });
+        const axisB = makeTestAxis({ name: 'b' });
+        const axisA = makeTestAxis({ name: 'a', parents: [axisB]});
+
+        const linkerMap = LinkerMap.fromColumns([
+            makeLinkerColumn({ name: 'abc', from: [axisA, axisB], to: [axisC] })
+        ]);
+
+        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: getNormalizedAxesList([axisA, axisB]), to: getNormalizedAxesList([axisC]), expected: ['abc'] });        
+    })
+
     test('Axis tree - without parents', () => {
         const [axisA, axisB] = getNormalizedAxesList([
             makeTestAxis({ name: 'a' }),
@@ -235,4 +260,27 @@ describe('Linker columns', () => {
         expect(linkerMap.getReachableByLinkersAxesFromAxes([c2])).not.toHaveLength(0);
         expect(linkerMap.getReachableByLinkersAxesFromAxes([c1])).not.toHaveLength(0);
     })
+
+    test('Non-linkable axes', () => {
+        const axisA = makeTestAxis({ name: 'a' });
+        const axisB = makeTestAxis({ name: 'b' });
+        const axisC = makeTestAxis({ name: 'c', parents: [axisA, axisB] });
+        const axisD = makeTestAxis({ name: 'd' });
+        const axisE = makeTestAxis({ name: 'e' });
+
+        const axesList = getNormalizedAxesList([axisA, axisB, axisC, axisD, axisE]);
+        const linkerMap = LinkerMap.fromColumns([
+            makeLinkerColumn({ name: 'linker1', from: [axisA, axisB, axisC], to: [axisD] })
+        ]);
+
+        expect(linkerMap.getNonLinkableAxes(
+            getNormalizedAxesList([axisA, axisB, axisC, axisD]),
+            getNormalizedAxesList([axisC, axisE])
+        ).map(v => v.name)).toEqual(['e']);
+
+        expect(linkerMap.getNonLinkableAxes(
+            [],
+            getNormalizedAxesList([axisA, axisB, axisC, axisE])
+        ).map(v => v.name)).toEqual(['a', 'b', 'c', 'e']);
+    })
 });

package/src/drivers/pframe/linker_columns.ts

@@ -167,7 +167,7 @@ export class LinkerMap implements LinkersData {
           .flatMap((targetKey) => {
             const linkers = startKeys
               .map((startKey) => this.searchLinkerPath(startKey, targetKey))
-              .reduce((shortestPath, path) => shortestPath.length && shortestPath.length < path.length ? shortestPath : path,
+              .reduce((shortestPath, path) => (shortestPath.length && shortestPath.length < path.length) || !path.length ? shortestPath : path,
                 [] as PColumnIdAndSpec[])
               .map((linker) => [linker.columnId, linker] as const);
             if (!linkers.length && throwWhenNoLinkExists) {
@@ -196,12 +196,19 @@ export class LinkerMap implements LinkersData {
   ): 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);
+    const targetKeys = targetAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+
+    const axes = Array.from(
+      new Map(
+        targetAxes
+          .filter((_targetAxis, idx) => {
+            const targetKey = targetKeys[idx];
+            return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);
+          })
+          .flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [canonicalizeJson(getAxisId(axis)), axis])),
+      ).values(),
+    );
+    return axes;
   }
 
   /** Get all axes that can be connected to sourceAxes by linkers */