@platforma-sdk/model 1.79.24 → 1.80.0

package/src/filters/converters/filterUiToExpressionImpl.test.ts

@@ -1,4 +1,3 @@
-import type { SUniversalPColumnId } from "@milaboratories/pl-model-common";
 import { describe, expect, it } from "vitest";
 import { convertFilterUiToExpressions } from "./filterUiToExpressionImpl";
 import { FilterSpec } from "../types";
@@ -8,8 +7,8 @@ describe("convertFilterUiToExpressions", () => {
     const uiFilter: FilterSpec = {
       type: "or",
       filters: [
-        { type: "isNA", column: "colA" as unknown as SUniversalPColumnId },
-        { type: "patternEquals", column: "colB" as unknown as SUniversalPColumnId, value: "test" },
+        { type: "isNA", column: "colA" },
+        { type: "patternEquals", column: "colB", value: "test" },
       ],
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -23,8 +22,8 @@ describe("convertFilterUiToExpressions", () => {
     const uiFilter: FilterSpec = {
       type: "and",
       filters: [
-        { type: "isNA", column: "colA" as unknown as SUniversalPColumnId },
-        { type: "greaterThan", column: "colNum" as unknown as SUniversalPColumnId, x: 10 },
+        { type: "isNA", column: "colA" },
+        { type: "greaterThan", column: "colNum", x: 10 },
       ],
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -37,7 +36,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "not" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "not",
-      filter: { type: "isNA", column: "colA" as unknown as SUniversalPColumnId },
+      filter: { type: "isNA", column: "colA" },
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result.type).toBe("not");
@@ -47,7 +46,7 @@ describe("convertFilterUiToExpressions", () => {
   });
 
   it('should compile "isNA" filter to ptabler expression', () => {
-    const uiFilter: FilterSpec = { type: "isNA", column: "colA" as unknown as SUniversalPColumnId };
+    const uiFilter: FilterSpec = { type: "isNA", column: "colA" };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
       type: "is_na",
@@ -58,7 +57,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "isNotNA" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "isNotNA",
-      column: "colA" as unknown as SUniversalPColumnId,
+      column: "colA",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -70,7 +69,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "patternEquals" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "patternEquals",
-      column: "colB" as unknown as SUniversalPColumnId,
+      column: "colB",
       value: "abc",
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -84,7 +83,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "patternNotEquals" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "patternNotEquals",
-      column: "colB" as unknown as SUniversalPColumnId,
+      column: "colB",
       value: "abc",
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -98,7 +97,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "patternContainSubsequence" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "patternContainSubsequence",
-      column: "colC" as unknown as SUniversalPColumnId,
+      column: "colC",
       value: "sub",
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -110,7 +109,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "patternNotContainSubsequence" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "patternNotContainSubsequence",
-      column: "colC" as unknown as SUniversalPColumnId,
+      column: "colC",
       value: "sub",
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -132,7 +131,7 @@ describe("convertFilterUiToExpressions", () => {
     testCases.forEach(({ type, expected }) => {
       const uiFilter: FilterSpec = {
         type,
-        column: "colNum" as unknown as SUniversalPColumnId,
+        column: "colNum",
         x: 10,
       };
       const result = convertFilterUiToExpressions(uiFilter);
@@ -147,8 +146,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "lessThanColumn" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "lessThanColumn",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -161,8 +160,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "lessThanColumn" filter with minDiff to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "lessThanColumn",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
       minDiff: 5,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -180,8 +179,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "greaterThanColumn" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "greaterThanColumn",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -194,8 +193,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "greaterThanColumn" filter with minDiff to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "greaterThanColumn",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
       minDiff: 7,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -213,8 +212,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "equalToColumn" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "equalToColumn",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -227,8 +226,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "greaterThanColumnOrEqual" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "greaterThanColumnOrEqual",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -241,8 +240,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "greaterThanColumnOrEqual" filter with minDiff to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "greaterThanColumnOrEqual",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
       minDiff: 2,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -260,8 +259,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "lessThanColumnOrEqual" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "lessThanColumnOrEqual",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
     };
     const result = convertFilterUiToExpressions(uiFilter);
     expect(result as any).toEqual({
@@ -274,8 +273,8 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "lessThanColumnOrEqual" filter with minDiff to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "lessThanColumnOrEqual",
-      column: "colNum1" as unknown as SUniversalPColumnId,
-      rhs: "colNum2" as unknown as SUniversalPColumnId,
+      column: "colNum1",
+      rhs: "colNum2",
       minDiff: 3,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -293,7 +292,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "topN" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "topN",
-      column: "colNum" as unknown as SUniversalPColumnId,
+      column: "colNum",
       n: 5,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -312,7 +311,7 @@ describe("convertFilterUiToExpressions", () => {
   it('should compile "bottomN" filter to ptabler expression', () => {
     const uiFilter: FilterSpec = {
       type: "bottomN",
-      column: "colNum" as unknown as SUniversalPColumnId,
+      column: "colNum",
       n: 3,
     };
     const result = convertFilterUiToExpressions(uiFilter);
@@ -335,15 +334,15 @@ describe("convertFilterUiToExpressions", () => {
         {
           type: "or",
           filters: [
-            { type: "isNA", column: "colA" as unknown as SUniversalPColumnId },
+            { type: "isNA", column: "colA" },
             {
               type: "patternEquals",
-              column: "colB" as unknown as SUniversalPColumnId,
+              column: "colB",
               value: "test",
             },
           ],
         },
-        { type: "greaterThan", column: "colNum" as unknown as SUniversalPColumnId, x: 10 },
+        { type: "greaterThan", column: "colNum", x: 10 },
       ],
     };
     const result = convertFilterUiToExpressions(uiFilter);

package/src/labels/derive_distinct_labels.ts

@@ -3,6 +3,7 @@ import {
   parseJson,
   readAnnotation,
   type AxisQualification,
+  type MatchQualifications,
   type PObjectId,
   type PObjectSpec,
   type StringifiedJson,
@@ -10,7 +11,6 @@ import {
 } from "@milaboratories/pl-model-common";
 import { throwError } from "@milaboratories/helpers";
 import { isFunction, isNil } from "es-toolkit";
-import type { MatchQualifications } from "../columns/column_collection_builder";
 
 export type { Trace, TraceEntry } from "@milaboratories/pl-model-common";
 

package/src/labels/derive_distinct_tooltips.test.ts

@@ -1,12 +1,13 @@
 import {
   Annotation,
   type AxisQualification,
+  type PColumn,
   type PColumnSpec,
   type PObjectId,
 } from "@milaboratories/pl-model-common";
 import { describe, expect, test } from "vitest";
 import { deriveDistinctTooltips, type TooltipEntry } from "./derive_distinct_tooltips";
-import type { ColumnSnapshot, MatchVariant } from "../columns";
+import type { PColumnDataUniversal } from "../render/internal";
 
 function createSpec(name: string, label?: string): PColumnSpec {
   return {
@@ -25,16 +26,18 @@ function axisQualification(
   return { axis: { name: axisName }, contextDomain };
 }
 
-function linkerSnapshot(name: string, label?: string): ColumnSnapshot<PObjectId> {
+function linkerSnapshot(name: string, label?: string): PColumn<PColumnDataUniversal | undefined> {
   return {
     id: `linker-${name}` as PObjectId,
     spec: createSpec(name, label),
-    dataStatus: "ready",
     data: undefined,
   };
 }
 
-function pathStep(linkerName: string, label?: string): MatchVariant["path"][number] {
+function pathStep(
+  linkerName: string,
+  label?: string,
+): NonNullable<TooltipEntry["linkerPath"]>[number] {
   return { linker: linkerSnapshot(linkerName, label) };
 }
 

package/src/labels/derive_distinct_tooltips.ts

@@ -3,10 +3,10 @@ import {
   PObjectId,
   readAnnotation,
   type AxisQualification,
+  type MatchQualifications,
   type PColumnSpec,
 } from "@milaboratories/pl-model-common";
 import { isNil } from "es-toolkit";
-import type { MatchQualifications, MatchVariant } from "../columns";
 
 export type TooltipEntry = {
   /** Main column spec — used for column-name fallback when no label. */
@@ -14,7 +14,7 @@ export type TooltipEntry = {
   /** Qualifications carried by this variant. */
   qualifications?: MatchQualifications;
   /** Linker steps traversed to reach the hit column. */
-  linkerPath?: MatchVariant["path"];
+  linkerPath?: ReadonlyArray<{ readonly linker: { readonly spec: PColumnSpec } }>;
   /** Position of this variant within the same physical column (1-based). */
   variantIndex?: number;
   /** Total variants for the same physical column. */
@@ -42,7 +42,7 @@ function formatTooltip(entry: TooltipEntry): undefined | string {
   if (hit !== undefined) sections.push(hit);
 
   if (sections.length <= 1) return undefined;
-  return sections.join("\n\n");
+  return sections.filter((s) => s.length > 0).join("\n\n");
 }
 
 const BULLET_1 = "  • ";

package/src/pframe_utils/axes.ts

@@ -71,7 +71,7 @@ function getKeysCombinations(idsLists: AxisId[][]) {
 }
 
 export function getAvailableWithLinkersAxes(
-  linkerColumns: PColumn<PColumnDataUniversal>[],
+  linkerColumns: PColumn<undefined | PColumnDataUniversal>[],
   blockAxes: AxesVault,
 ): AxesVault {
   const linkerMap = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec));
@@ -89,7 +89,7 @@ export function getAvailableWithLinkersAxes(
 }
 
 /** Add columns with fully compatible axes created from partial compatible ones */
-export function enrichCompatible<T extends Omit<PColumn<PColumnDataUniversal>, "data">>(
+export function enrichCompatible<T extends Omit<PColumn<undefined | PColumnDataUniversal>, "data">>(
   blockAxes: AxesVault,
   columns: T[],
 ): T[] {

package/src/pframe_utils/columns.ts

@@ -1,10 +1,4 @@
-import type {
-  PColumn,
-  PColumnSpec,
-  PColumnLazy,
-  PFrameDef,
-  PObjectId,
-} from "@milaboratories/pl-model-common";
+import type { PColumn, PColumnSpec, PFrameDef, PObjectId } from "@milaboratories/pl-model-common";
 import {
   getNormalizedAxesList,
   getAxisId,
@@ -12,18 +6,18 @@ import {
   isLinkerColumn,
   matchAxisId,
   isLabelColumn,
+  extractPObjectId,
 } from "@milaboratories/pl-model-common";
 import type { AxesVault } from "./axes";
 import { enrichCompatible, getAvailableWithLinkersAxes } from "./axes";
 import type { RenderCtxBase, PColumnDataUniversal } from "../render";
 import { PColumnCollection } from "../render";
-import { ColumnCollectionBuilder } from "../columns";
-import { collectCtxColumnSnapshotProviders } from "../columns/ctx_column_sources";
+import { ColumnsCollection } from "../columns";
 
 export function getAllRelatedColumns<A, U>(
   ctx: RenderCtxBase<A, U>,
   predicate: (spec: PColumnSpec) => boolean,
-): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>> {
+): PFrameDef<PColumn<undefined | PColumnDataUniversal>> {
   // if current block doesn't produce own columns then use all columns from result pool
   const columns = new PColumnCollection();
   columns.addColumnProvider(ctx.resultPool);
@@ -54,10 +48,10 @@ export function getRelatedColumns<A, U>(
     columns: rootColumns,
     predicate,
   }: {
-    columns: PColumn<PColumnDataUniversal>[];
+    columns: PColumn<undefined | PColumnDataUniversal>[];
     predicate: (spec: PColumnSpec) => boolean;
   },
-): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>> {
+): PFrameDef<PColumn<undefined | PColumnDataUniversal>> {
   // if current block has its own columns then take from result pool only compatible with them
   const columns = new PColumnCollection();
   columns.addColumnProvider(ctx.resultPool);
@@ -161,7 +155,7 @@ export function getRelatedColumns<A, U>(
 /** Column ids that discovery confirms integrate with the block, or `undefined` when it can't decide. */
 function discoverIntegrableColumnIds<A, U>(
   ctx: RenderCtxBase<A, U>,
-  rootColumns: PColumn<PColumnDataUniversal>[],
+  rootColumns: PColumn<undefined | PColumnDataUniversal>[],
 ): Set<PObjectId> | undefined {
   const anchorSpecs = Array.from(
     new Map(rootColumns.map((c) => [canonicalizeJson(c.spec), c.spec])).values(),
@@ -169,17 +163,14 @@ function discoverIntegrableColumnIds<A, U>(
   if (anchorSpecs.length === 0) return undefined;
 
   try {
-    const collection = new ColumnCollectionBuilder()
-      .addSources(collectCtxColumnSnapshotProviders(ctx))
-      .build({
-        allowPartialColumnList: true,
+    const columns = ColumnsCollection(undefined, { ctx: ctx.ctx })
+      .discover({
+        mode: "enrichment",
+        maxHops: 4,
         anchors: Object.fromEntries(anchorSpecs.map((spec, i) => [`anchor_${i}`, spec])),
-      });
-    try {
-      return new Set(collection.findColumns({ mode: "enrichment" }).map((m) => m.column.id));
-    } finally {
-      collection.dispose();
-    }
+      })
+      .getColumns();
+    return new Set(columns.map((c) => extractPObjectId(c.id)));
   } catch {
     return undefined;
   }

package/src/pframe_utils/index.ts

@@ -310,7 +310,7 @@ export async function getColumnsFull(
 export async function getColumnOrAxisValueLabelsId(
   handle: PFrameHandle,
   strAxisId: CanonicalizedJson<AxisId>,
-): Promise<PObjectId | undefined> {
+): Promise<undefined | PObjectId> {
   const labelColumns = await getColumnsFull(handle, {
     selectedSources: [],
     strictlyCompatible: false,

package/src/render/accessor.ts

@@ -1,16 +1,17 @@
-import type {
-  AnyLogHandle,
-  ImportProgress,
-  LocalBlobHandleAndSize,
+import {
+  type AnyLogHandle,
+  type ImportProgress,
+  type LocalBlobHandleAndSize,
+  type RemoteBlobHandleAndSize,
+  type FolderURL,
+  type ArchiveFormat,
+  type ProgressLogWithInfo,
+  type RangeBytes,
+  isPColumn,
+  mapPObjectData,
   PColumn,
   PObject,
-  RemoteBlobHandleAndSize,
-  FolderURL,
-  ArchiveFormat,
-  ProgressLogWithInfo,
-  RangeBytes,
 } from "@milaboratories/pl-model-common";
-import { isPColumn, mapPObjectData } from "@milaboratories/pl-model-common";
 import { getCfgRenderCtx } from "../internal";
 import { FutureRef } from "./future";
 import type { AccessorHandle } from "./internal";
@@ -124,15 +125,11 @@ export class TreeNodeAccessor {
     return this.resolveWithCommon({}, ...transformedSteps);
   }
 
-  public resolveAny(
-    ...steps: [
-      Omit<FieldTraversalStep, "errorIfFieldNotSet"> & {
-        errorIfFieldNotAssigned: true;
-      },
-    ]
+  public traverse(
+    ...steps: [Omit<FieldTraversalStep, "errorIfFieldNotSet"> & { errorIfFieldNotAssigned: true }]
   ): TreeNodeAccessor;
-  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
-  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+  public traverse(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public traverse(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
     return this.resolveWithCommon({}, ...steps);
   }
 
@@ -204,6 +201,10 @@ export class TreeNodeAccessor {
     return JSON.parse(content);
   }
 
+  public hasData(): boolean {
+    return getCfgRenderCtx().hasData(this.handle);
+  }
+
   public getDataBase64(): string | undefined {
     return getCfgRenderCtx().getDataBase64(this.handle);
   }
@@ -250,9 +251,21 @@ export class TreeNodeAccessor {
     return this.getDataAsJson<T>();
   }
 
-  /**
-   *
-   */
+  public getFileContentAsBase64(range?: RangeBytes): FutureRef<string | undefined> {
+    return new FutureRef(getCfgRenderCtx().getBlobContentAsBase64(this.handle, range));
+  }
+
+  public getFileContentAsString(range?: RangeBytes): FutureRef<string | undefined> {
+    return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range));
+  }
+
+  public getFileContentAsJson<T>(range?: RangeBytes): FutureRef<T | undefined> {
+    return new FutureRef<string | undefined>(
+      getCfgRenderCtx().getBlobContentAsString(this.handle, range),
+    ).mapDefined((v) => JSON.parse(v) as T);
+  }
+
+  /** @deprecated */
   public getPColumns(
     errorOnUnknownField: boolean = false,
     prefix: string = "",
@@ -268,9 +281,7 @@ export class TreeNodeAccessor {
     return pf;
   }
 
-  /**
-   *
-   */
+  /** @deprecated */
   public parsePObjectCollection(
     errorOnUnknownField: boolean = false,
     prefix: string = "",
@@ -290,20 +301,6 @@ export class TreeNodeAccessor {
     return result;
   }
 
-  public getFileContentAsBase64(range?: RangeBytes): FutureRef<string | undefined> {
-    return new FutureRef(getCfgRenderCtx().getBlobContentAsBase64(this.handle, range));
-  }
-
-  public getFileContentAsString(range?: RangeBytes): FutureRef<string | undefined> {
-    return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range));
-  }
-
-  public getFileContentAsJson<T>(range?: RangeBytes): FutureRef<T | undefined> {
-    return new FutureRef<string | undefined>(
-      getCfgRenderCtx().getBlobContentAsString(this.handle, range),
-    ).mapDefined((v) => JSON.parse(v) as T);
-  }
-
   /**
    * @deprecated use getFileContentAsBase64
    */