@platforma-sdk/model 1.10.12 → 1.12.0

package/dist/render/util/label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"label.d.ts","sourceRoot":"","sources":["../../../src/render/util/label.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAChD,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;EAKrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAGpD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;WAAsB,CAAC;AACzC,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAQ1C,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EAAE,EACX,aAAa,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,WAAW,EACtC,GAAG,GAAE,kBAAuB,GAC3B,gBAAgB,CAAC,CAAC,CAAC,EAAE,CA4GvB"}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PlatformaSDKVersion = "1.10.12";
+export declare const PlatformaSDKVersion = "1.12.0";
 //# 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,YAAY,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,WAAW,CAAC"}

package/package.json

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

package/src/render/api.ts

@@ -24,6 +24,7 @@ import { getCfgRenderCtx } from '../internal';
 import { TreeNodeAccessor } from './accessor';
 import { FutureRef } from './future';
 import { GlobalCfgRenderCtx, MainAccessorName, StagingAccessorName } from './internal';
+import { deriveLabels, LabelDerivationOps } from './util/label';
 
 export class ResultPool {
   private readonly ctx: GlobalCfgRenderCtx = getCfgRenderCtx();
@@ -40,13 +41,20 @@ export class ResultPool {
 
   public getOptions(
     predicate: (spec: PObjectSpec) => boolean,
-    labelFn: (spec: PObjectSpec, ref: Ref) => string = this.defaultLabelFn
+    label?: ((spec: PObjectSpec, ref: Ref) => string) | LabelDerivationOps
   ): Option[] {
-    return this.getSpecs()
-      .entries.filter((s) => predicate(s.obj))
-      .map((s) => ({
+    const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
+    if (typeof label === 'object' || typeof label === 'undefined') {
+      return deriveLabels(filtered, (o) => o.obj, label ?? {}).map(
+        ({ value: { ref }, label }) => ({
+          ref,
+          label
+        })
+      );
+    } else
+      return filtered.map((s) => ({
         ref: s.ref,
-        label: labelFn(s.obj, s.ref)
+        label: label(s.obj, s.ref)
       }));
   }
 

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

@@ -0,0 +1,98 @@
+import { test, expect } from '@jest/globals';
+import { deriveLabels, PAnnotationLabel, PAnnotationTrace, Trace } from './label';
+import { PColumnSpec } from '@milaboratories/pl-model-common';
+
+function tracesToSpecs(traces: Trace[]) {
+  return traces.map(
+    (t) =>
+      ({
+        kind: 'PColumn',
+        name: 'name',
+        valueType: 'Int',
+        annotations: {
+          [PAnnotationTrace]: JSON.stringify(t),
+          [PAnnotationLabel]: 'Label'
+        },
+        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: 'later wins',
+    traces: [
+      [
+        { type: 't1', label: 'T1L1' },
+        { type: 't2', label: 'T2L1' }
+      ],
+      [
+        { type: 't1', label: 'T1L2' },
+        { type: 't2', label: 'T2L2' }
+      ]
+    ],
+    labels: ['T2L1', 'T2L2']
+  },
+  {
+    name: 'importance wins',
+    traces: [
+      [
+        { type: 't1', importance: 100, label: 'T1L1' },
+        { type: 't2', label: 'T2L1' }
+      ],
+      [
+        { type: 't1', importance: 100, label: 'T1L2' },
+        { type: 't2', label: 'T2L2' }
+      ]
+    ],
+    labels: ['T1L1', 'T1L2']
+  },
+  {
+    name: 'uniqueness wins',
+    traces: [
+      [
+        { type: 't1', label: 'T1L1' },
+        { type: 't2', label: 'T2L1' }
+      ],
+      [
+        { type: 't1', label: 'T1L2' },
+        { type: 't2', label: 'T2L1' }
+      ]
+    ],
+    labels: ['T1L1', 'T1L2']
+  },
+  {
+    name: 'combinatoric solution',
+    traces: [
+      [
+        { type: 't1', label: 'T1L1' },
+        { type: 't2', label: 'T2L1' }
+      ],
+      [
+        { type: 't1', label: 'T1L1' },
+        { type: 't2', label: 'T2L2' }
+      ],
+      [
+        { type: 't1', label: 'T1L2' },
+        { type: 't2', label: 'T2L2' }
+      ]
+    ],
+    labels: ['T1L1 / T2L1', 'T1L1 / T2L2', 'T1L2 / T2L2']
+  }
+])('test label derivation: $name', ({ 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));
+});
+
+test('test fallback to native labels in label derivation', () => {
+  expect(deriveLabels(tracesToSpecs([[], []]), (s) => s).map((r) => r.label)).toEqual([
+    'Label',
+    'Label'
+  ]);
+});

package/src/render/util/label.ts

@@ -0,0 +1,147 @@
+import { PObjectSpec } from '@milaboratories/pl-model-common';
+import { z } from 'zod';
+
+export const PAnnotationLabel = 'pl7.app/label';
+export const PAnnotationTrace = 'pl7.app/trace';
+
+export type RecordsWithLabel<T> = {
+  value: T;
+  label: string;
+};
+
+export type LabelDerivationOps = {
+  includeNativeLabel?: boolean;
+  separator?: string;
+};
+
+export const TraceEntry = z.object({
+  type: z.string(),
+  importance: z.number().optional(),
+  id: z.string().optional(),
+  label: z.string()
+});
+export type TraceEntry = z.infer<typeof TraceEntry>;
+type FullTraceEntry = TraceEntry & { fullType: string; occurenceIndex: number };
+
+export const Trace = z.array(TraceEntry);
+export type Trace = z.infer<typeof Trace>;
+type FullTrace = FullTraceEntry[];
+
+const DistancePenalty = 0.001;
+
+const LabelType = '__LABEL__';
+const LabelTypeFull = '__LABEL__@1';
+
+export function deriveLabels<T>(
+  values: T[],
+  specExtractor: (obj: T) => PObjectSpec,
+  ops: LabelDerivationOps = {}
+): RecordsWithLabel<T>[] {
+  const importances = new Map<string, number>();
+
+  // number of times certain type occured among all of the
+  const numberOfRecordsWithType = new Map<string, number>();
+
+  const enrichedRecords = values.map((value) => {
+    const spec = specExtractor(value);
+    const label = spec.annotations?.[PAnnotationLabel];
+    const traceStr = spec.annotations?.[PAnnotationTrace];
+    const trace = (traceStr ? Trace.safeParse(JSON.parse(traceStr)).data : undefined) ?? [];
+
+    if (label) trace.splice(0, 0, { label, type: LabelType, importance: -2 });
+
+    const fullTrace: FullTrace = [];
+
+    const occurences = new Map<string, number>();
+    for (let i = trace.length - 1; i >= 0; --i) {
+      const { type: typeName } = trace[i];
+      const importance = trace[i].importance ?? 0;
+      const occurenceIndex = (occurences.get(typeName) ?? 0) + 1;
+      occurences.set(typeName, occurenceIndex);
+      const fullType = `${typeName}@${occurenceIndex}`;
+      numberOfRecordsWithType.set(fullType, (numberOfRecordsWithType.get(fullType) ?? 0) + 1);
+      importances.set(
+        fullType,
+        Math.max(
+          importances.get(fullType) ?? Number.NEGATIVE_INFINITY,
+          importance - (trace.length - i) * DistancePenalty
+        )
+      );
+      fullTrace.push({ ...trace[i], fullType, occurenceIndex });
+    }
+    fullTrace.reverse();
+    return {
+      value,
+      spec,
+      label,
+      fullTrace
+    };
+  });
+
+  // excluding repeated types (i.e. ..@2, ..@3, etc.) not found in some records
+  const mainTypes: string[] = [];
+  // repeated types (i.e. ..@2, ..@3, etc.) not found in some records
+  const secondaryTypes: string[] = [];
+
+  const allTypeRecords = [...importances];
+  // sorting: most important types go first
+  allTypeRecords.sort(([, i1], [, i2]) => i2 - i1);
+
+  for (const [typeName] of allTypeRecords) {
+    if (typeName.endsWith('@1') || numberOfRecordsWithType.get(typeName) === values.length)
+      mainTypes.push(typeName);
+    else secondaryTypes.push(typeName);
+  }
+
+  const calculate = (includedTypes: Set<string>) =>
+    enrichedRecords.map((r) => {
+      const labelSet = r.fullTrace
+        .filter((fm) => includedTypes.has(fm.fullType))
+        .map((fm) => fm.label);
+      const sep = ops.separator ?? ' / ';
+      return {
+        label: labelSet.join(sep),
+        value: r.value
+      } satisfies RecordsWithLabel<T>;
+    });
+
+  if (mainTypes.length === 0) {
+    if (secondaryTypes.length !== 0) throw new Error('Assertion error.');
+    return calculate(new Set(LabelTypeFull));
+  }
+
+  //
+  // includedTypes = 2
+  // *  *
+  // T0 T1 T2 T3 T4 T5
+  //          *
+  // additinalType = 3
+  //
+  // Resulting set: T0, T1, T3
+  //
+  let includedTypes = 0;
+  let additinalType = 0;
+  while (includedTypes < mainTypes.length) {
+    const currentSet = new Set<string>();
+    for (let i = 0; i < includedTypes; ++i) currentSet.add(mainTypes[i]);
+    currentSet.add(mainTypes[additinalType]);
+
+    const candidateResult = calculate(currentSet);
+
+    // checking if labels uniquely separate our records
+    if (new Set(candidateResult.map((c) => c.label)).size === values.length) {
+      if (ops.includeNativeLabel) {
+        currentSet.add(LabelTypeFull);
+        return calculate(currentSet);
+      } else return candidateResult;
+    }
+
+    additinalType++;
+    if (additinalType == mainTypes.length) {
+      includedTypes++;
+      additinalType = includedTypes;
+    }
+  }
+
+  return calculate(new Set([...mainTypes, ...secondaryTypes]));
+}