@platforma-sdk/model 1.53.11 → 1.53.13

package/src/render/util/label.test.ts

@@ -1,279 +1,279 @@
-import { Annotation, PColumnSpec } from '@milaboratories/pl-model-common';
-import { expect, test } from 'vitest';
-import { deriveLabels, Trace } from './label';
+import { Annotation, PColumnSpec } from "@milaboratories/pl-model-common";
+import { expect, test } from "vitest";
+import { deriveLabels, Trace } from "./label";
 
 function tracesToSpecs(traces: Trace[]) {
   return traces.map(
     (t) =>
       ({
-        kind: 'PColumn',
-        name: 'name',
-        valueType: 'Int',
+        kind: "PColumn",
+        name: "name",
+        valueType: "Int",
         annotations: {
           [Annotation.Trace]: JSON.stringify(t),
-          [Annotation.Label]: 'Label'
+          [Annotation.Label]: "Label",
         },
-        axesSpec: []
-      }) satisfies PColumnSpec
+        axesSpec: [],
+      }) satisfies PColumnSpec,
   );
 }
 test.each<{ name: string; traces: Trace[]; labels: string[] }>([
   {
-    name: 'simple',
-    traces: [[{ type: 't1', label: 'L1' }], [{ type: 't1', label: 'L2' }]],
-    labels: ['L1', 'L2']
+    name: "simple",
+    traces: [[{ type: "t1", label: "L1" }], [{ type: "t1", label: "L2" }]],
+    labels: ["L1", "L2"],
   },
   {
-    name: 'later wins',
+    name: "later wins",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L2' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+      ],
     ],
-    labels: ['T2L1', 'T2L2']
+    labels: ["T2L1", "T2L2"],
   },
   {
-    name: 'importance wins',
+    name: "importance wins",
     traces: [
       [
-        { type: 't1', importance: 100, label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", importance: 100, label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', importance: 100, label: 'T1L2' },
-        { type: 't2', label: 'T2L2' }
-      ]
+        { type: "t1", importance: 100, label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+      ],
     ],
-    labels: ['T1L1', 'T1L2']
+    labels: ["T1L1", "T1L2"],
   },
   {
-    name: 'uniqueness wins',
+    name: "uniqueness wins",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L1' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L1" },
+      ],
     ],
-    labels: ['T1L1', 'T1L2']
+    labels: ["T1L1", "T1L2"],
   },
   {
-    name: 'combinatoric solution',
+    name: "combinatoric solution",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L2' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L2" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L2' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+      ],
     ],
-    labels: ['T1L1 / T2L1', 'T1L1 / T2L2', 'T1L2 / T2L2']
+    labels: ["T1L1 / T2L1", "T1L1 / T2L2", "T1L2 / T2L2"],
   },
   {
-    name: 'different importance and id',
+    name: "different importance and id",
     traces: [
-      [{ type: 'sameType', importance: 10, id: 'id1', label: 'High importance' }],
-      [{ type: 'sameType', importance: 5, id: 'id2', label: 'Low importance' }]
+      [{ type: "sameType", importance: 10, id: "id1", label: "High importance" }],
+      [{ type: "sameType", importance: 5, id: "id2", label: "Low importance" }],
     ],
-    labels: ['High importance', 'Low importance']
+    labels: ["High importance", "Low importance"],
   },
   {
-    name: 'mixed common and different entries',
+    name: "mixed common and different entries",
     traces: [
       [
-        { type: 'commonType', importance: 1, id: 'common', label: 'Common entry' },
-        { type: 'uniqueType', importance: 10, id: 'id1', label: 'Unique entry 1' }
+        { type: "commonType", importance: 1, id: "common", label: "Common entry" },
+        { type: "uniqueType", importance: 10, id: "id1", label: "Unique entry 1" },
       ],
       [
-        { type: 'commonType', importance: 1, id: 'common', label: 'Common entry' },
-        { type: 'uniqueType', importance: 5, id: 'id2', label: 'Unique entry 2' }
-      ]
+        { type: "commonType", importance: 1, id: "common", label: "Common entry" },
+        { type: "uniqueType", importance: 5, id: "id2", label: "Unique entry 2" },
+      ],
     ],
-    labels: ['Unique entry 1', 'Unique entry 2']
-  }
-])('test label derivation: $name', ({ name, traces, labels }) => {
+    labels: ["Unique entry 1", "Unique entry 2"],
+  },
+])("test label derivation: $name", ({ traces, labels }) => {
   expect(deriveLabels(tracesToSpecs(traces), (s) => s).map((r) => r.label)).toEqual(labels);
   expect(
-    deriveLabels(tracesToSpecs(traces), (s) => s, { includeNativeLabel: true }).map((r) => r.label)
-  ).toEqual(labels.map((l) => 'Label / ' + l));
+    deriveLabels(tracesToSpecs(traces), (s) => s, { includeNativeLabel: true }).map((r) => r.label),
+  ).toEqual(labels.map((l) => "Label / " + l));
 });
 
-test('test fallback to native labels in label derivation', () => {
+test("test fallback to native labels in label derivation", () => {
   expect(deriveLabels(tracesToSpecs([[], []]), (s) => s).map((r) => r.label)).toEqual([
-    'Label',
-    'Label'
+    "Label",
+    "Label",
   ]);
 });
 
 test.each<{ name: string; traces: Trace[]; labels: string[] }>([
   {
-    name: 'removes redundant low-importance type when high-importance alone suffices',
+    name: "removes redundant low-importance type when high-importance alone suffices",
     traces: [
       [
-        { type: 't1', importance: 10, label: 'High1' },
-        { type: 't2', importance: 1, label: 'Low1' }
+        { type: "t1", importance: 10, label: "High1" },
+        { type: "t2", importance: 1, label: "Low1" },
       ],
       [
-        { type: 't1', importance: 10, label: 'High2' },
-        { type: 't2', importance: 1, label: 'Low2' }
-      ]
+        { type: "t1", importance: 10, label: "High2" },
+        { type: "t2", importance: 1, label: "Low2" },
+      ],
     ],
     // Both t1 and t2 distinguish, but t2 (low importance) should be removed since t1 alone suffices
-    labels: ['High1', 'High2']
+    labels: ["High1", "High2"],
   },
   {
-    name: 'keeps both types when both are needed for uniqueness',
+    name: "keeps both types when both are needed for uniqueness",
     traces: [
       [
-        { type: 't1', importance: 10, label: 'A' },
-        { type: 't2', importance: 1, label: 'X' }
+        { type: "t1", importance: 10, label: "A" },
+        { type: "t2", importance: 1, label: "X" },
       ],
       [
-        { type: 't1', importance: 10, label: 'A' },
-        { type: 't2', importance: 1, label: 'Y' }
+        { type: "t1", importance: 10, label: "A" },
+        { type: "t2", importance: 1, label: "Y" },
       ],
       [
-        { type: 't1', importance: 10, label: 'B' },
-        { type: 't2', importance: 1, label: 'Y' }
-      ]
+        { type: "t1", importance: 10, label: "B" },
+        { type: "t2", importance: 1, label: "Y" },
+      ],
     ],
     // Neither t1 nor t2 alone can distinguish all three, need both
-    labels: ['A / X', 'A / Y', 'B / Y']
+    labels: ["A / X", "A / Y", "B / Y"],
   },
   {
-    name: 'removes multiple redundant types greedily',
+    name: "removes multiple redundant types greedily",
     traces: [
       [
-        { type: 't1', importance: 100, label: 'Unique1' },
-        { type: 't2', importance: 10, label: 'Same' },
-        { type: 't3', importance: 1, label: 'Same' }
+        { type: "t1", importance: 100, label: "Unique1" },
+        { type: "t2", importance: 10, label: "Same" },
+        { type: "t3", importance: 1, label: "Same" },
       ],
       [
-        { type: 't1', importance: 100, label: 'Unique2' },
-        { type: 't2', importance: 10, label: 'Same' },
-        { type: 't3', importance: 1, label: 'Same' }
-      ]
+        { type: "t1", importance: 100, label: "Unique2" },
+        { type: "t2", importance: 10, label: "Same" },
+        { type: "t3", importance: 1, label: "Same" },
+      ],
     ],
     // t1 alone distinguishes; t2 and t3 are redundant and should be removed
-    labels: ['Unique1', 'Unique2']
+    labels: ["Unique1", "Unique2"],
   },
   {
-    name: 'fallback case: removes types that do not reduce cardinality',
+    name: "fallback case: removes types that do not reduce cardinality",
     traces: [
       // Two columns with identical traces - cannot be distinguished
       [
-        { type: 't1', importance: 100, label: 'A' },
-        { type: 't2', importance: 10, label: 'X' },
-        { type: 't3', importance: 1, label: 'Same' }
+        { type: "t1", importance: 100, label: "A" },
+        { type: "t2", importance: 10, label: "X" },
+        { type: "t3", importance: 1, label: "Same" },
       ],
       [
-        { type: 't1', importance: 100, label: 'A' },
-        { type: 't2', importance: 10, label: 'X' },
-        { type: 't3', importance: 1, label: 'Same' }
+        { type: "t1", importance: 100, label: "A" },
+        { type: "t2", importance: 10, label: "X" },
+        { type: "t3", importance: 1, label: "Same" },
       ],
       // Third column is different
       [
-        { type: 't1', importance: 100, label: 'B' },
-        { type: 't2', importance: 10, label: 'Y' },
-        { type: 't3', importance: 1, label: 'Same' }
-      ]
+        { type: "t1", importance: 100, label: "B" },
+        { type: "t2", importance: 10, label: "Y" },
+        { type: "t3", importance: 1, label: "Same" },
+      ],
     ],
     // Cannot achieve full uniqueness (2 columns are identical), but t3 (Same) can be removed
     // since it doesn't help distinguish anything. t1 alone gives cardinality 2.
-    labels: ['A', 'A', 'B']
-  }
-])('test label minimization: $name', ({ traces, labels }) => {
+    labels: ["A", "A", "B"],
+  },
+])("test label minimization: $name", ({ traces, labels }) => {
   expect(deriveLabels(tracesToSpecs(traces), (s) => s).map((r) => r.label)).toEqual(labels);
 });
 
 test.each<{ name: string; traces: Trace[]; labels: string[]; forceTraceElements: string[] }>([
   {
-    name: 'force one element',
+    name: "force one element",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L2' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+      ],
     ],
-    labels: ['T1L1', 'T1L2'],
-    forceTraceElements: ['t1']
+    labels: ["T1L1", "T1L2"],
+    forceTraceElements: ["t1"],
   },
   {
-    name: 'force multiple elements',
+    name: "force multiple elements",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' },
-        { type: 't3', label: 'T3L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
+        { type: "t3", label: "T3L1" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L2' },
-        { type: 't3', label: 'T3L2' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+        { type: "t3", label: "T3L2" },
+      ],
     ],
-    labels: ['T1L1 / T3L1', 'T1L2 / T3L2'],
-    forceTraceElements: ['t1', 't3']
+    labels: ["T1L1 / T3L1", "T1L2 / T3L2"],
+    forceTraceElements: ["t1", "t3"],
   },
   {
-    name: 'force element not in all traces',
+    name: "force element not in all traces",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
-      [{ type: 't2', label: 'T2L2' }]
+      [{ type: "t2", label: "T2L2" }],
     ],
-    labels: ['T1L1 / T2L1', 'T2L2'],
-    forceTraceElements: ['t1']
+    labels: ["T1L1 / T2L1", "T2L2"],
+    forceTraceElements: ["t1"],
   },
   {
-    name: 'force element with includeNativeLabel',
+    name: "force element with includeNativeLabel",
     traces: [
       [
-        { type: 't1', label: 'T1L1' },
-        { type: 't2', label: 'T2L1' }
+        { type: "t1", label: "T1L1" },
+        { type: "t2", label: "T2L1" },
       ],
       [
-        { type: 't1', label: 'T1L2' },
-        { type: 't2', label: 'T2L2' }
-      ]
+        { type: "t1", label: "T1L2" },
+        { type: "t2", label: "T2L2" },
+      ],
     ],
-    labels: ['T1L1', 'T1L2'],
-    forceTraceElements: ['t1']
-  }
+    labels: ["T1L1", "T1L2"],
+    forceTraceElements: ["t1"],
+  },
 ])(
-  'test label derivation with forceTraceElements: $name',
+  "test label derivation with forceTraceElements: $name",
   ({ name, traces, labels, forceTraceElements }) => {
     expect(
-      deriveLabels(tracesToSpecs(traces), (s) => s, { forceTraceElements }).map((r) => r.label)
+      deriveLabels(tracesToSpecs(traces), (s) => s, { forceTraceElements }).map((r) => r.label),
     ).toEqual(labels);
 
-    if (name === 'force element with includeNativeLabel') {
+    if (name === "force element with includeNativeLabel") {
       expect(
         deriveLabels(tracesToSpecs(traces), (s) => s, {
           forceTraceElements,
-          includeNativeLabel: true
-        }).map((r) => r.label)
-      ).toEqual(labels.map(l => 'Label / ' + l));
+          includeNativeLabel: true,
+        }).map((r) => r.label),
+      ).toEqual(labels.map((l) => "Label / " + l));
     }
-  }
+  },
 );

package/src/render/util/label.ts

@@ -1,5 +1,10 @@
-import { Annotation, parseJson, readAnnotation, type PObjectSpec } from '@milaboratories/pl-model-common';
-import { z } from 'zod';
+import {
+  Annotation,
+  parseJson,
+  readAnnotation,
+  type PObjectSpec,
+} from "@milaboratories/pl-model-common";
+import { z } from "zod";
 
 export type RecordsWithLabel<T> = {
   value: T;
@@ -31,16 +36,18 @@ export type Trace = z.infer<typeof Trace>;
 type FullTrace = FullTraceEntry[];
 
 // Define the possible return types for the specExtractor function
-type SpecExtractorResult = PObjectSpec | {
-  spec: PObjectSpec;
-  prefixTrace?: TraceEntry[];
-  suffixTrace?: TraceEntry[];
-};
+type SpecExtractorResult =
+  | PObjectSpec
+  | {
+      spec: PObjectSpec;
+      prefixTrace?: TraceEntry[];
+      suffixTrace?: TraceEntry[];
+    };
 
 const DistancePenalty = 0.001;
 
-const LabelType = '__LABEL__';
-const LabelTypeFull = '__LABEL__@1';
+const LabelType = "__LABEL__";
+const LabelTypeFull = "__LABEL__@1";
 
 export function deriveLabels<T>(
   values: T[],
@@ -49,9 +56,10 @@ export function deriveLabels<T>(
 ): RecordsWithLabel<T>[] {
   const importances = new Map<string, number>();
 
-  const forceTraceElements = (ops.forceTraceElements !== undefined && ops.forceTraceElements.length > 0)
-    ? new Set(ops.forceTraceElements)
-    : undefined;
+  const forceTraceElements =
+    ops.forceTraceElements !== undefined && ops.forceTraceElements.length > 0
+      ? new Set(ops.forceTraceElements)
+      : undefined;
 
   // number of times certain type occurred among all of the
   const numberOfRecordsWithType = new Map<string, number>();
@@ -63,7 +71,7 @@ export function deriveLabels<T>(
     let suffixTrace: TraceEntry[] | undefined;
 
     // Check if the result is the new structure or just PObjectSpec
-    if ('spec' in extractorResult && typeof extractorResult.spec === 'object') {
+    if ("spec" in extractorResult && typeof extractorResult.spec === "object") {
       // It's the new structure { spec, prefixTrace?, suffixTrace? }
       spec = extractorResult.spec;
       prefixTrace = extractorResult.prefixTrace;
@@ -77,11 +85,7 @@ export function deriveLabels<T>(
     const traceStr = readAnnotation(spec, Annotation.Trace);
     const baseTrace = (traceStr ? Trace.safeParse(parseJson(traceStr)).data : undefined) ?? [];
 
-    const trace = [
-      ...(prefixTrace ?? []),
-      ...baseTrace,
-      ...(suffixTrace ?? []),
-    ];
+    const trace = [...(prefixTrace ?? []), ...baseTrace, ...(suffixTrace ?? [])];
 
     if (label !== undefined) {
       const labelEntry = { label, type: LabelType, importance: -2 };
@@ -127,7 +131,7 @@ export function deriveLabels<T>(
   allTypeRecords.sort(([, i1], [, i2]) => i2 - i1);
 
   for (const [typeName] of allTypeRecords) {
-    if (typeName.endsWith('@1') || numberOfRecordsWithType.get(typeName) === values.length)
+    if (typeName.endsWith("@1") || numberOfRecordsWithType.get(typeName) === values.length)
       mainTypes.push(typeName);
     else secondaryTypes.push(typeName);
   }
@@ -136,20 +140,20 @@ export function deriveLabels<T>(
     const result: RecordsWithLabel<T>[] = [];
     for (let i = 0; i < enrichedRecords.length; i++) {
       const r = enrichedRecords[i];
-      const includedTrace = r.fullTrace
-        .filter((fm) => includedTypes.has(fm.fullType)
-          || (forceTraceElements && forceTraceElements.has(fm.type)));
+      const includedTrace = r.fullTrace.filter(
+        (fm) =>
+          includedTypes.has(fm.fullType) || (forceTraceElements && forceTraceElements.has(fm.type)),
+      );
       if (includedTrace.length === 0) {
         if (force)
           result.push({
-            label: 'Unlabeled',
+            label: "Unlabeled",
             value: r.value,
           } satisfies RecordsWithLabel<T>);
         else return undefined;
       }
-      const labelSet = includedTrace
-        .map((fm) => fm.label);
-      const sep = ops.separator ?? ' / ';
+      const labelSet = includedTrace.map((fm) => fm.label);
+      const sep = ops.separator ?? " / ";
       result.push({
         label: labelSet.join(sep),
         value: r.value,
@@ -172,16 +176,21 @@ export function deriveLabels<T>(
 
     // Get types sorted by importance ascending (lowest first), excluding forced elements
     const removableSorted = [...typeSet]
-      .filter((t) =>
-        !forceTraceElements?.has(t.split('@')[0])
-        && !(ops.includeNativeLabel && t === LabelTypeFull))
+      .filter(
+        (t) =>
+          !forceTraceElements?.has(t.split("@")[0]) &&
+          !(ops.includeNativeLabel && t === LabelTypeFull),
+      )
       .sort((a, b) => (importances.get(a) ?? 0) - (importances.get(b) ?? 0));
 
     for (const typeToRemove of removableSorted) {
       const reducedSet = new Set(typeSet);
       reducedSet.delete(typeToRemove);
       const candidateResult = calculate(reducedSet);
-      if (candidateResult !== undefined && countUniqueLabels(candidateResult) >= currentCardinality) {
+      if (
+        candidateResult !== undefined &&
+        countUniqueLabels(candidateResult) >= currentCardinality
+      ) {
         typeSet.delete(typeToRemove);
       }
     }
@@ -189,7 +198,8 @@ export function deriveLabels<T>(
   };
 
   if (mainTypes.length === 0) {
-    if (secondaryTypes.length !== 0) throw new Error('Non-empty secondary types list while main types list is empty.');
+    if (secondaryTypes.length !== 0)
+      throw new Error("Non-empty secondary types list while main types list is empty.");
     return calculate(new Set(LabelTypeFull), true)!;
   }
 
@@ -208,8 +218,7 @@ export function deriveLabels<T>(
     const currentSet = new Set<string>();
     if (ops.includeNativeLabel) currentSet.add(LabelTypeFull);
     for (let i = 0; i < includedTypes; ++i) currentSet.add(mainTypes[i]);
-    if (additionalType >= 0)
-      currentSet.add(mainTypes[additionalType]);
+    if (additionalType >= 0) currentSet.add(mainTypes[additionalType]);
 
     const candidateResult = calculate(currentSet);