@platforma-sdk/model 1.53.11 → 1.53.13

package/src/filters/converter.ts

@@ -1,127 +1,139 @@
-import { assertNever } from '@milaboratories/pl-model-common';
-import { and, col, lit, or, rank, type Expression, type ExpressionImpl } from '@milaboratories/ptabler-expression-js';
-import type { FilterSpec } from '../filters';
+import { assertNever } from "@milaboratories/pl-model-common";
+import {
+  and,
+  col,
+  lit,
+  or,
+  rank,
+  type Expression,
+  type ExpressionImpl,
+} from "@milaboratories/ptabler-expression-js";
+import type { FilterSpec } from "../filters";
 
 export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionImpl {
-  if (value.type === 'or') {
-    const expressions = value.filters.filter((f) => f.type !== undefined).map(convertFilterUiToExpressionImpl);
+  if (value.type === "or") {
+    const expressions = value.filters
+      .filter((f) => f.type !== undefined)
+      .map(convertFilterUiToExpressionImpl);
     if (expressions.length === 0) {
-      throw new Error('OR filter requires at least one operand');
+      throw new Error("OR filter requires at least one operand");
     }
     return or(...expressions);
   }
 
-  if (value.type === 'and') {
-    const expressions = value.filters.filter((f) => f.type !== undefined).map(convertFilterUiToExpressionImpl);
+  if (value.type === "and") {
+    const expressions = value.filters
+      .filter((f) => f.type !== undefined)
+      .map(convertFilterUiToExpressionImpl);
     if (expressions.length === 0) {
-      throw new Error('AND filter requires at least one operand');
+      throw new Error("AND filter requires at least one operand");
     }
     return and(...expressions);
   }
 
-  if (value.type === 'not') {
+  if (value.type === "not") {
     return convertFilterUiToExpressionImpl(value.filter).not();
   }
 
-  if (value.type === 'isNA') {
+  if (value.type === "isNA") {
     return col(value.column).isNull();
   }
 
-  if (value.type === 'isNotNA') {
+  if (value.type === "isNotNA") {
     return col(value.column).isNotNull();
   }
 
-  if (value.type === 'patternEquals') {
+  if (value.type === "patternEquals") {
     return col(value.column).eq(lit(value.value));
   }
 
-  if (value.type === 'patternNotEquals') {
+  if (value.type === "patternNotEquals") {
     return col(value.column).neq(lit(value.value));
   }
 
-  if (value.type === 'patternContainSubsequence') {
+  if (value.type === "patternContainSubsequence") {
     return col(value.column).strContains(value.value, false, true);
   }
 
-  if (value.type === 'patternNotContainSubsequence') {
+  if (value.type === "patternNotContainSubsequence") {
     return col(value.column).strContains(value.value, false, true).not();
   }
 
-  if (value.type === 'equal') {
+  if (value.type === "equal") {
     return col(value.column).eq(lit(value.x));
   }
 
-  if (value.type === 'notEqual') {
+  if (value.type === "notEqual") {
     return col(value.column).neq(lit(value.x));
   }
 
-  if (value.type === 'lessThan') {
+  if (value.type === "lessThan") {
     return col(value.column).lt(lit(value.x));
   }
 
-  if (value.type === 'greaterThan') {
+  if (value.type === "greaterThan") {
     return col(value.column).gt(lit(value.x));
   }
 
-  if (value.type === 'lessThanOrEqual') {
+  if (value.type === "lessThanOrEqual") {
     return col(value.column).le(lit(value.x));
   }
 
-  if (value.type === 'greaterThanOrEqual') {
+  if (value.type === "greaterThanOrEqual") {
     return col(value.column).ge(lit(value.x));
   }
 
-  if (value.type === 'equalToColumn') {
+  if (value.type === "equalToColumn") {
     return col(value.column).eq(col(value.rhs));
   }
 
-  if (value.type === 'greaterThanColumn') {
+  if (value.type === "greaterThanColumn") {
     if (value.minDiff !== undefined && value.minDiff !== 0) {
       return col(value.column).plus(lit(value.minDiff)).gt(col(value.rhs));
     }
     return col(value.column).gt(col(value.rhs));
   }
 
-  if (value.type === 'lessThanColumn') {
+  if (value.type === "lessThanColumn") {
     if (value.minDiff !== undefined && value.minDiff !== 0) {
       return col(value.column).plus(lit(value.minDiff)).lt(col(value.rhs));
     }
     return col(value.column).lt(col(value.rhs));
   }
 
-  if (value.type === 'greaterThanColumnOrEqual') {
+  if (value.type === "greaterThanColumnOrEqual") {
     if (value.minDiff !== undefined && value.minDiff !== 0) {
       return col(value.column).plus(lit(value.minDiff)).ge(col(value.rhs));
     }
     return col(value.column).ge(col(value.rhs));
   }
 
-  if (value.type === 'lessThanColumnOrEqual') {
+  if (value.type === "lessThanColumnOrEqual") {
     if (value.minDiff !== undefined && value.minDiff !== 0) {
       return col(value.column).plus(lit(value.minDiff)).le(col(value.rhs));
     }
     return col(value.column).le(col(value.rhs));
   }
 
-  if (value.type === 'topN') {
+  if (value.type === "topN") {
     return rank(col(value.column), true).over([]).le(lit(value.n));
   }
 
-  if (value.type === 'bottomN') {
+  if (value.type === "bottomN") {
     return rank(col(value.column), false).over([]).le(lit(value.n));
   }
 
   if (
-    value.type === 'patternMatchesRegularExpression'
-    || value.type === 'patternFuzzyContainSubsequence'
-    || value.type === 'inSet'
-    || value.type === 'notInSet'
+    value.type === "patternMatchesRegularExpression" ||
+    value.type === "patternFuzzyContainSubsequence" ||
+    value.type === "inSet" ||
+    value.type === "notInSet"
   ) {
-    throw new Error('Not implemented filter type: ' + value.type);
+    throw new Error("Not implemented filter type: " + value.type);
   }
 
   if (value.type === undefined) {
-    throw new Error('Filter type is undefined, this should not happen');
+    throw new Error("Filter type is undefined, this should not happen");
   }
 
   assertNever(value);

package/src/filters/index.ts

@@ -1,2 +1,2 @@
-export * from './converter';
-export * from './types';
+export * from "./converter";
+export * from "./types";

package/src/filters/types.ts

@@ -1,6 +1,6 @@
-import type { PColumnSpec, SUniversalPColumnId } from '@milaboratories/pl-model-common';
+import type { PColumnSpec, SUniversalPColumnId } from "@milaboratories/pl-model-common";
 
-export type SimplifiedPColumnSpec = Pick<PColumnSpec, 'valueType' | 'annotations'>;
+export type SimplifiedPColumnSpec = Pick<PColumnSpec, "valueType" | "annotations">;
 
 export type SimplifiedUniversalPColumnEntry = {
   id: SUniversalPColumnId;
@@ -9,45 +9,50 @@ export type SimplifiedUniversalPColumnEntry = {
 };
 
 export type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> =
-  | CommonLeaf & Leaf
-  | CommonNode & { type: 'not'; filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf> }
-  | CommonNode & { type: 'or'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] }
-  | CommonNode & { type: 'and'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] };
+  | (CommonLeaf & Leaf)
+  | (CommonNode & { type: "not"; filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf> })
+  | (CommonNode & { type: "or"; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] })
+  | (CommonNode & { type: "and"; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] });
 
 export type FilterSpecLeaf<T = SUniversalPColumnId> =
   | { type: undefined }
-  | { type: 'isNA'; column: T }
-  | { type: 'isNotNA'; column: T }
-
-  | { type: 'patternEquals'; column: T; value: string }
-  | { type: 'patternNotEquals'; column: T; value: string }
-  | { type: 'patternContainSubsequence'; column: T; value: string }
-  | { type: 'patternNotContainSubsequence'; column: T; value: string }
-  | { type: 'patternMatchesRegularExpression'; column: T; value: string }
-  | { type: 'patternFuzzyContainSubsequence'; column: T; value: string; maxEdits?: number; substitutionsOnly?: boolean; wildcard?: string }
-
-  | { type: 'inSet'; column: T; value: string[] }
-  | { type: 'notInSet'; column: T; value: string[] }
-
-  | { type: 'topN'; column: T; n: number }
-  | { type: 'bottomN'; column: T; n: number }
-
-  | { type: 'equal'; column: T; x: number }
-  | { type: 'notEqual'; column: T; x: number }
-  | { type: 'lessThan'; column: T; x: number }
-  | { type: 'greaterThan'; column: T; x: number }
-  | { type: 'lessThanOrEqual'; column: T; x: number }
-  | { type: 'greaterThanOrEqual'; column: T; x: number }
-
-  | { type: 'equalToColumn'; column: T; rhs: T }
-  | { type: 'lessThanColumn'; column: T; rhs: T; minDiff?: number }
-  | { type: 'greaterThanColumn'; column: T; rhs: T; minDiff?: number }
-  | { type: 'lessThanColumnOrEqual'; column: T; rhs: T; minDiff?: number }
-  | { type: 'greaterThanColumnOrEqual'; column: T; rhs: T; minDiff?: number };
-
-export type FilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> =
-  FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
-
-export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>['type'];
+  | { type: "isNA"; column: T }
+  | { type: "isNotNA"; column: T }
+  | { type: "patternEquals"; column: T; value: string }
+  | { type: "patternNotEquals"; column: T; value: string }
+  | { type: "patternContainSubsequence"; column: T; value: string }
+  | { type: "patternNotContainSubsequence"; column: T; value: string }
+  | { type: "patternMatchesRegularExpression"; column: T; value: string }
+  | {
+      type: "patternFuzzyContainSubsequence";
+      column: T;
+      value: string;
+      maxEdits?: number;
+      substitutionsOnly?: boolean;
+      wildcard?: string;
+    }
+  | { type: "inSet"; column: T; value: string[] }
+  | { type: "notInSet"; column: T; value: string[] }
+  | { type: "topN"; column: T; n: number }
+  | { type: "bottomN"; column: T; n: number }
+  | { type: "equal"; column: T; x: number }
+  | { type: "notEqual"; column: T; x: number }
+  | { type: "lessThan"; column: T; x: number }
+  | { type: "greaterThan"; column: T; x: number }
+  | { type: "lessThanOrEqual"; column: T; x: number }
+  | { type: "greaterThanOrEqual"; column: T; x: number }
+  | { type: "equalToColumn"; column: T; rhs: T }
+  | { type: "lessThanColumn"; column: T; rhs: T; minDiff?: number }
+  | { type: "greaterThanColumn"; column: T; rhs: T; minDiff?: number }
+  | { type: "lessThanColumnOrEqual"; column: T; rhs: T; minDiff?: number }
+  | { type: "greaterThanColumnOrEqual"; column: T; rhs: T; minDiff?: number };
+
+export type FilterSpec<
+  Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>,
+  CommonNode = {},
+  CommonLeaf = CommonNode,
+> = FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
+
+export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>["type"];
 
 export type FilterSpecOfType<T extends FilterSpecType> = Extract<FilterSpec, { type: T }>;

package/src/global.d.ts

@@ -1,4 +1,4 @@
-import type { Platforma, PlatformaApiVersion } from './platforma';
+import type { Platforma, PlatformaApiVersion } from "./platforma";
 
 declare global {
   /** Global factory method returning platforma instance */

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from './block_state_patch';
-export * from './block_state_util';
-export * from './block_storage';
-export * from './builder';
-export { BlockModelV3 } from './block_model';
+export * from "./block_state_patch";
+export * from "./block_state_util";
+export * from "./block_storage";
+export * from "./builder";
+export { BlockModelV3 } from "./block_model";
 export {
   DataModel,
   DataModelBuilder,
@@ -11,25 +11,25 @@ export {
   defineDataVersions,
   defaultRecover,
   makeDataVersioned,
-} from './block_migrations';
-export * from './bconfig';
-export * from './components';
-export * from './config';
-export * from './pframe';
-export * from './platforma';
-export * from './ref_util';
-export * from './render';
-export * from './sdk_info';
-export * from './raw_globals';
-export * from './block_api_v1';
-export * from './block_api_v2';
-export * from './filters';
-export * from './annotations';
-export * from './pframe_utils';
+} from "./block_migrations";
+export * from "./bconfig";
+export * from "./components";
+export * from "./config";
+export * from "./pframe";
+export * from "./platforma";
+export * from "./ref_util";
+export * from "./render";
+export * from "./sdk_info";
+export * from "./raw_globals";
+export * from "./block_api_v1";
+export * from "./block_api_v2";
+export * from "./filters";
+export * from "./annotations";
+export * from "./pframe_utils";
 
 // reexporting everything from SDK model
-export * from '@milaboratories/pl-model-common';
-export * from '@milaboratories/pl-error-like';
+export * from "@milaboratories/pl-model-common";
+export * from "@milaboratories/pl-error-like";
 
-export * as JsRenderInternal from './render/internal';
-export { getEnvironmentValue } from './env_value';
+export * as JsRenderInternal from "./render/internal";
+export { getEnvironmentValue } from "./env_value";

package/src/internal.ts

@@ -1,37 +1,44 @@
-import type { OutputWithStatus } from '@milaboratories/pl-model-common';
-import { } from './global';
-import type { Platforma, PlatformaApiVersion } from './platforma';
-import type { FutureHandle, GlobalCfgRenderCtx } from './render/internal';
-import type { ConfigRenderLambda, ConfigRenderLambdaFlags } from './bconfig';
+import type { OutputWithStatus } from "@milaboratories/pl-model-common";
+import {} from "./global";
+import type { Platforma, PlatformaApiVersion } from "./platforma";
+import type { FutureHandle, GlobalCfgRenderCtx } from "./render/internal";
+import type { ConfigRenderLambda, ConfigRenderLambdaFlags } from "./bconfig";
 
 /** Utility code helping to identify whether the code is running in actual UI environment */
 export function isInUI() {
   return (
-    typeof globalThis.getPlatforma !== 'undefined' || typeof globalThis.platforma !== 'undefined'
+    typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined"
   );
 }
 
 /** Utility code helping to retrieve a platforma instance form the environment */
 export function getPlatformaInstance<
   Args = unknown,
-  Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>,
+  Outputs extends Record<string, OutputWithStatus<unknown>> = Record<
+    string,
+    OutputWithStatus<unknown>
+  >,
   UiState = unknown,
   Href extends `/${string}` = `/${string}`,
->(config?: { sdkVersion: string; apiVersion: PlatformaApiVersion }): Platforma<Args, Outputs, UiState, Href> {
-  if (config && typeof globalThis.getPlatforma === 'function')
+>(config?: {
+  sdkVersion: string;
+  apiVersion: PlatformaApiVersion;
+}): Platforma<Args, Outputs, UiState, Href> {
+  if (config && typeof globalThis.getPlatforma === "function")
     return globalThis.getPlatforma(config);
-  else if (typeof globalThis.platforma !== 'undefined') return globalThis.platforma as Platforma<Args, Outputs, UiState, Href>;
-  else throw new Error('Can\'t get platforma instance.');
+  else if (typeof globalThis.platforma !== "undefined")
+    return globalThis.platforma as Platforma<Args, Outputs, UiState, Href>;
+  else throw new Error("Can't get platforma instance.");
 }
 
 export function tryGetCfgRenderCtx(): GlobalCfgRenderCtx | undefined {
-  if (typeof globalThis.cfgRenderCtx !== 'undefined') return globalThis.cfgRenderCtx;
+  if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
   else return undefined;
 }
 
 export function getCfgRenderCtx(): GlobalCfgRenderCtx {
-  if (typeof globalThis.cfgRenderCtx !== 'undefined') return globalThis.cfgRenderCtx;
-  else throw new Error('Not in config rendering context');
+  if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
+  else throw new Error("Not in config rendering context");
 }
 
 export function tryRegisterCallback(key: string, callback: (...args: any[]) => any): boolean {
@@ -78,9 +85,12 @@ export function createRenderLambda<T = unknown>(opts: CreateLambdaOptions): Conf
 }
 
 /** Registers a callback and returns a ConfigRenderLambda descriptor. */
-export function createAndRegisterRenderLambda<T = unknown>(opts: CreateLambdaOptions & {
-  lambda: (...args: any[]) => any;
-}, replace?: boolean): ConfigRenderLambda<T> {
+export function createAndRegisterRenderLambda<T = unknown>(
+  opts: CreateLambdaOptions & {
+    lambda: (...args: any[]) => any;
+  },
+  replace?: boolean,
+): ConfigRenderLambda<T> {
   const { handle, lambda, ...flags } = opts;
 
   if (replace) {

package/src/pframe.ts

@@ -11,8 +11,8 @@ import type {
   TableRange,
   UniqueValuesRequest,
   UniqueValuesResponse,
-} from '@milaboratories/pl-model-common';
-import { patchInSetFilters } from './render/util/pframe_upgraders';
+} from "@milaboratories/pl-model-common";
+import { patchInSetFilters } from "./render/util/pframe_upgraders";
 
 export class PFrameImpl implements PFrame {
   constructor(private readonly handle: PFrameHandle) {}
@@ -48,7 +48,7 @@ export class PFrameImpl implements PFrame {
 
   private getPlatforma() {
     if (platforma === undefined) {
-      throw new Error('Platforma instance is not available in the current context.');
+      throw new Error("Platforma instance is not available in the current context.");
     }
     return platforma;
   }

package/src/pframe_utils/columns.ts

@@ -1,24 +1,38 @@
-import type { PColumn, PColumnSpec, PColumnLazy, PFrameDef } from '@milaboratories/pl-model-common';
-import { getNormalizedAxesList, getAxisId, canonicalizeJson, isLinkerColumn, matchAxisId, isLabelColumn } from '@milaboratories/pl-model-common';
-import type { AxesVault } from '../components';
-import { enrichCompatible, getAvailableWithLinkersAxes } from '../components';
-import type { RenderCtxBase, PColumnDataUniversal } from '../render';
-import { PColumnCollection } from '../render';
+import type { PColumn, PColumnSpec, PColumnLazy, PFrameDef } from "@milaboratories/pl-model-common";
+import {
+  getNormalizedAxesList,
+  getAxisId,
+  canonicalizeJson,
+  isLinkerColumn,
+  matchAxisId,
+  isLabelColumn,
+} from "@milaboratories/pl-model-common";
+import type { AxesVault } from "../components";
+import { enrichCompatible, getAvailableWithLinkersAxes } from "../components";
+import type { RenderCtxBase, PColumnDataUniversal } from "../render";
+import { PColumnCollection } from "../render";
 
 export function getAllRelatedColumns<A, U>(
-  ctx: RenderCtxBase<A, U>, predicate: (spec: PColumnSpec) => boolean,
+  ctx: RenderCtxBase<A, U>,
+  predicate: (spec: PColumnSpec) => boolean,
 ): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<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);
-  const allColumns = columns.getColumns(predicate, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
+  const allColumns =
+    columns.getColumns(predicate, {
+      dontWaitAllData: true,
+      overrideLabelAnnotation: false,
+    }) ?? [];
 
-  const allAxes: AxesVault = new Map(allColumns
-    .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
-    .map((axisSpec) => {
-      const axisId = getAxisId(axisSpec);
-      return [canonicalizeJson(axisId), axisSpec];
-    }));
+  const allAxes: AxesVault = new Map(
+    allColumns
+      .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
+      .map((axisSpec) => {
+        const axisId = getAxisId(axisSpec);
+        return [canonicalizeJson(axisId), axisSpec];
+      }),
+  );
 
   // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
   const extendedColumns = enrichCompatible(allAxes, allColumns);
@@ -26,10 +40,16 @@ export function getAllRelatedColumns<A, U>(
   return extendedColumns;
 }
 
-export function getRelatedColumns<A, U>(ctx: RenderCtxBase<A, U>, { columns: rootColumns, predicate }: {
-  columns: PColumn<PColumnDataUniversal>[];
-  predicate: (spec: PColumnSpec) => boolean;
-}): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>> {
+export function getRelatedColumns<A, U>(
+  ctx: RenderCtxBase<A, U>,
+  {
+    columns: rootColumns,
+    predicate,
+  }: {
+    columns: PColumn<PColumnDataUniversal>[];
+    predicate: (spec: PColumnSpec) => boolean;
+  },
+): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<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);
@@ -48,7 +68,10 @@ export function getRelatedColumns<A, U>(ctx: RenderCtxBase<A, U>, { columns: roo
   }
 
   // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
-  const linkerColumns = columns.getColumns((spec) => predicate(spec) && isLinkerColumn(spec), { dontWaitAllData: true }) ?? [];
+  const linkerColumns =
+    columns.getColumns((spec) => predicate(spec) && isLinkerColumn(spec), {
+      dontWaitAllData: true,
+    }) ?? [];
   const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
 
   // all possible axes from connected linkers
@@ -59,10 +82,19 @@ export function getRelatedColumns<A, U>(ctx: RenderCtxBase<A, U>, { columns: roo
 
   const blockAxesArr = Array.from(blockAxes.values());
   // all compatible with block columns but without label columns
-  let compatibleWithoutLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
-    const axisId = getAxisId(axisSpec);
-    return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-  }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+  let compatibleWithoutLabels = (
+    columns.getColumns(
+      (spec) =>
+        predicate(spec) &&
+        spec.axesSpec.some((axisSpec) => {
+          const axisId = getAxisId(axisSpec);
+          return blockAxesArr.some((selectorAxisSpec) =>
+            matchAxisId(getAxisId(selectorAxisSpec), axisId),
+          );
+        }),
+      { dontWaitAllData: true, overrideLabelAnnotation: false },
+    ) ?? []
+  ).filter((column) => !isLabelColumn(column.spec));
 
   // extend axes set for label columns request
   for (const c of compatibleWithoutLabels) {
@@ -74,16 +106,34 @@ export function getRelatedColumns<A, U>(ctx: RenderCtxBase<A, U>, { columns: roo
 
   const allAxesArr = Array.from(allAxes.values());
   // extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
-  compatibleWithoutLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.every((axisSpec) => {
-    const axisId = getAxisId(axisSpec);
-    return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-  }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+  compatibleWithoutLabels = (
+    columns.getColumns(
+      (spec) =>
+        predicate(spec) &&
+        spec.axesSpec.every((axisSpec) => {
+          const axisId = getAxisId(axisSpec);
+          return allAxesArr.some((selectorAxisSpec) =>
+            matchAxisId(getAxisId(selectorAxisSpec), axisId),
+          );
+        }),
+      { dontWaitAllData: true, overrideLabelAnnotation: false },
+    ) ?? []
+  ).filter((column) => !isLabelColumn(column.spec));
 
   // label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
-  const compatibleLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
-    const axisId = getAxisId(axisSpec);
-    return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-  }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
+  const compatibleLabels = (
+    columns.getColumns(
+      (spec) =>
+        predicate(spec) &&
+        spec.axesSpec.some((axisSpec) => {
+          const axisId = getAxisId(axisSpec);
+          return allAxesArr.some((selectorAxisSpec) =>
+            matchAxisId(getAxisId(selectorAxisSpec), axisId),
+          );
+        }),
+      { dontWaitAllData: true, overrideLabelAnnotation: false },
+    ) ?? []
+  ).filter((column) => isLabelColumn(column.spec));
 
   const compatible = [...compatibleWithoutLabels, ...compatibleLabels];