@platforma-sdk/model 1.24.9 → 1.24.11

package/src/builder.ts

@@ -1,10 +1,12 @@
-import { BlockRenderingMode, BlockSection, ValueOrErrors } from '@milaboratories/pl-model-common';
-import { Checked, ConfigResult, getImmediate, PlResourceEntry, TypedConfig } from './config';
+import type { BlockRenderingMode, BlockSection, ValueOrErrors, AnyFunction } from '@milaboratories/pl-model-common';
+import type { Checked, ConfigResult, TypedConfig } from './config';
+import { getImmediate } from './config';
 import { getPlatformaInstance, isInUI, tryRegisterCallback } from './internal';
-import { Platforma } from './platforma';
-import { InferRenderFunctionReturn, RenderCtx, RenderFunction } from './render';
+import type { Platforma } from './platforma';
+import type { InferRenderFunctionReturn, RenderFunction } from './render';
+import { RenderCtx } from './render';
 import { PlatformaSDKVersion } from './version';
-import {
+import type {
   TypedConfigOrConfigLambda,
   ConfigRenderLambda,
   StdCtxArgsOnly,
@@ -12,8 +14,10 @@ import {
   ResolveCfgType,
   ExtractFunctionHandleReturn,
   BlockConfigContainer,
+  ConfigRenderLambdaFlags,
+} from './bconfig';
+import {
   downgradeCfgOrLambda,
-  ConfigRenderLambdaFlags
 } from './bconfig';
 
 type SectionsExpectedType = readonly BlockSection[];
@@ -23,10 +27,11 @@ type SectionsCfgChecked<Cfg extends TypedConfig, Args, UiState> = Checked<
   ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>> extends SectionsExpectedType ? true : false
 >;
 
-type SectionsRFChecked<RF extends Function> = Checked<
-  RF,
-  InferRenderFunctionReturn<RF> extends SectionsExpectedType ? true : false
->;
+// TODO (Unused type in code)
+// type SectionsRFChecked<RF extends Function> = Checked<
+//   RF,
+//   InferRenderFunctionReturn<RF> extends SectionsExpectedType ? true : false
+// >;
 
 type InputsValidExpectedType = boolean;
 
@@ -35,10 +40,11 @@ type InputsValidCfgChecked<Cfg extends TypedConfig, Args, UiState> = Checked<
   ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>> extends InputsValidExpectedType ? true : false
 >;
 
-type InputsValidRFChecked<RF extends Function> = Checked<
-  RF,
-  InferRenderFunctionReturn<RF> extends InputsValidExpectedType ? true : false
->;
+// TODO (Unused type in code)
+// type InputsValidRFChecked<RF extends Function> = Checked<
+//   RF,
+//   InferRenderFunctionReturn<RF> extends InputsValidExpectedType ? true : false
+// >;
 
 type NoOb = Record<string, never>;
 
@@ -49,7 +55,7 @@ export class BlockModel<
   Args,
   OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,
   UiState,
-  Href extends `/${string}` = '/'
+  Href extends `/${string}` = '/',
 > {
   private constructor(
     private readonly _renderingMode: BlockRenderingMode,
@@ -58,7 +64,7 @@ export class BlockModel<
     private readonly _outputs: OutputsCfg,
     private readonly _inputsValid: TypedConfigOrConfigLambda,
     private readonly _sections: TypedConfigOrConfigLambda,
-    private readonly _title: ConfigRenderLambda | undefined
+    private readonly _title: ConfigRenderLambda | undefined,
   ) {}
 
   /** Initiates configuration builder */
@@ -83,7 +89,7 @@ export class BlockModel<
       {},
       getImmediate(true),
       getImmediate([]),
-      undefined
+      undefined,
     );
   }
 
@@ -119,8 +125,8 @@ export class BlockModel<
   >;
   public output(
     key: string,
-    cfgOrRf: TypedConfig | Function,
-    flags: ConfigRenderLambdaFlags = {}
+    cfgOrRf: TypedConfig | AnyFunction,
+    flags: ConfigRenderLambdaFlags = {},
   ): BlockModel<Args, OutputsCfg, UiState, Href> {
     if (typeof cfgOrRf === 'function') {
       const handle = `output#${key}`;
@@ -134,12 +140,12 @@ export class BlockModel<
           [key]: {
             __renderLambda: true,
             handle,
-            ...flags
-          } satisfies ConfigRenderLambda
+            ...flags,
+          } satisfies ConfigRenderLambda,
         },
         this._inputsValid,
         this._sections,
-        this._title
+        this._title,
       );
     } else
       return new BlockModel(
@@ -148,24 +154,24 @@ export class BlockModel<
         this._initialUiState,
         {
           ...this._outputs,
-          [key]: cfgOrRf
+          [key]: cfgOrRf,
         },
         this._inputsValid,
         this._sections,
-        this._title
+        this._title,
       );
   }
 
   /** Shortcut for {@link output} with retentive flag set to true. */
   public retentiveOutput<const Key extends string, const RF extends RenderFunction<Args, UiState>>(
     key: Key,
-    rf: RF
+    rf: RF,
   ): BlockModel<
-    Args,
+      Args,
     OutputsCfg & { [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> },
     UiState,
     Href
-  > {
+    > {
     return this.output(key, rf, { retentive: true });
   }
 
@@ -179,7 +185,7 @@ export class BlockModel<
     rf: RF
   ): BlockModel<Args, OutputsCfg, UiState, Href>;
   public argsValid(
-    cfgOrRf: TypedConfig | Function
+    cfgOrRf: TypedConfig | AnyFunction,
   ): BlockModel<Args, OutputsCfg, UiState, `/${string}`> {
     if (typeof cfgOrRf === 'function') {
       tryRegisterCallback('inputsValid', () => cfgOrRf(new RenderCtx()));
@@ -190,10 +196,10 @@ export class BlockModel<
         this._outputs,
         {
           __renderLambda: true,
-          handle: 'inputsValid'
+          handle: 'inputsValid',
         } satisfies ConfigRenderLambda,
         this._sections,
-        this._title
+        this._title,
       );
     } else
       return new BlockModel<Args, OutputsCfg, UiState>(
@@ -203,7 +209,7 @@ export class BlockModel<
         this._outputs,
         cfgOrRf,
         this._sections,
-        this._title
+        this._title,
       );
   }
 
@@ -215,7 +221,7 @@ export class BlockModel<
   /** Sets the config to generate list of section in the left block overviews panel */
   public sections<
     const Ret extends SectionsExpectedType,
-    const RF extends RenderFunction<Args, UiState, Ret>
+    const RF extends RenderFunction<Args, UiState, Ret>,
   >(rf: RF): BlockModel<Args, OutputsCfg, UiState, DeriveHref<ReturnType<RF>>>;
   public sections<const Cfg extends TypedConfig>(
     cfg: Cfg & SectionsCfgChecked<Cfg, Args, UiState>
@@ -226,7 +232,7 @@ export class BlockModel<
     DeriveHref<ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>>>
   >;
   public sections(
-    arrOrCfgOrRf: SectionsExpectedType | TypedConfig | Function
+    arrOrCfgOrRf: SectionsExpectedType | TypedConfig | AnyFunction,
   ): BlockModel<Args, OutputsCfg, UiState, `/${string}`> {
     if (Array.isArray(arrOrCfgOrRf)) {
       return this.sections(getImmediate(arrOrCfgOrRf));
@@ -239,7 +245,7 @@ export class BlockModel<
         this._outputs,
         this._inputsValid,
         { __renderLambda: true, handle: 'sections' } as ConfigRenderLambda,
-        this._title
+        this._title,
       );
     } else
       return new BlockModel<Args, OutputsCfg, UiState>(
@@ -249,13 +255,13 @@ export class BlockModel<
         this._outputs,
         this._inputsValid,
         arrOrCfgOrRf as TypedConfig,
-        this._title
+        this._title,
       );
   }
 
   /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
   public title(
-    rf: RenderFunction<Args, UiState, string>
+    rf: RenderFunction<Args, UiState, string>,
   ): BlockModel<Args, OutputsCfg, UiState, Href> {
     tryRegisterCallback('title', () => rf(new RenderCtx()));
     return new BlockModel<Args, OutputsCfg, UiState, Href>(
@@ -265,7 +271,7 @@ export class BlockModel<
       this._outputs,
       this._inputsValid,
       this._sections,
-      { __renderLambda: true, handle: 'title' } as ConfigRenderLambda
+      { __renderLambda: true, handle: 'title' } as ConfigRenderLambda,
     );
   }
 
@@ -281,7 +287,7 @@ export class BlockModel<
       this._outputs,
       this._inputsValid,
       this._sections,
-      this._title
+      this._title,
     );
   }
 
@@ -294,7 +300,7 @@ export class BlockModel<
       this._outputs,
       this._inputsValid,
       this._sections,
-      this._title
+      this._title,
     );
   }
 
@@ -307,7 +313,7 @@ export class BlockModel<
       this._outputs,
       this._inputsValid,
       this._sections,
-      this._title
+      this._title,
     );
   }
 
@@ -331,7 +337,7 @@ export class BlockModel<
         inputsValid: this._inputsValid,
         sections: this._sections,
         title: this._title,
-        outputs: this._outputs
+        outputs: this._outputs,
       },
 
       // fields below are added to allow previous desktop versions read generated configs
@@ -341,8 +347,8 @@ export class BlockModel<
       inputsValid: downgradeCfgOrLambda(this._inputsValid),
       sections: downgradeCfgOrLambda(this._sections),
       outputs: Object.fromEntries(
-        Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)])
-      )
+        Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)]),
+      ),
     };
 
     if (!isInUI())
@@ -362,7 +368,7 @@ export type InferOutputType<CfgOrFH, Args, UiState> = CfgOrFH extends TypedConfi
 type InferOutputsFromConfigs<
   Args,
   OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,
-  UiState
+  UiState,
 > = {
   [Key in keyof OutputsCfg]: ValueOrErrors<InferOutputType<OutputsCfg[Key], Args, UiState>>;
 };

package/src/components/PFrameForGraphs.ts

@@ -1,64 +1,66 @@
+import type {
+  AxisId,
+  PColumn,
+  PColumnValues,
+  PFrameHandle,
+  PObjectId,
+  ValueType } from '@milaboratories/pl-model-common';
 import {
-    AxisId,
-    getAxisId,
-    isPColumn,
-    matchAxisId,
-    PColumn,
-    PColumnValues,
-    PFrameHandle,
-    PObjectId,
-    ValueType,
+  getAxisId,
+  isPColumn,
+  matchAxisId,
 } from '@milaboratories/pl-model-common';
-import {RenderCtx, TreeNodeAccessor} from '../render';
+import type { RenderCtx } from '../render';
+import { TreeNodeAccessor } from '../render';
 
 /** Create id for column copy with added keys in axes domains */
 const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
-    let wid = id.toString();
-    domains?.forEach(domain => {
-        if (domain) {
-            for (const [k, v] of Object.entries(domain)) {
-                wid += k;
-                wid += v;
-            }
-        }
-    });
-    return wid;
+  let wid = id.toString();
+  domains?.forEach((domain) => {
+    if (domain) {
+      for (const [k, v] of Object.entries(domain)) {
+        wid += k;
+        wid += v;
+      }
+    }
+  });
+  return wid;
 };
 
 /** All combinations with 1 key from each list */
 function getKeysCombinations(idsLists: AxisId[][]) {
-    if (!idsLists.length) {
-        return [];
-    }
-    let result: AxisId[][] = [[]];
-    idsLists.forEach(list => {
-        const nextResult: AxisId[][] = [];
-        list.forEach(key => {
-            nextResult.push(...result.map(resultItem => [...resultItem, key]));
-        });
-        result = nextResult;
+  if (!idsLists.length) {
+    return [];
+  }
+  let result: AxisId[][] = [[]];
+  idsLists.forEach((list) => {
+    const nextResult: AxisId[][] = [];
+    list.forEach((key) => {
+      nextResult.push(...result.map((resultItem) => [...resultItem, key]));
     });
-    return result;
+    result = nextResult;
+  });
+  return result;
 }
 
 /** Check if axes of secondary column are exactly in axes of main column */
 function checkFullCompatibility(
-    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
-    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+  mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+  secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>,
 ): boolean {
-    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
-    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
-    return secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id) && matchAxisId(id, mainId)));
+  const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+  const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+  return secondaryAxesIds.every((id) => mainAxesIds.some((mainId) => matchAxisId(mainId, id) && matchAxisId(id, mainId)));
 }
 
 /** Check if axes of secondary column are in axes of main column, but they can have compatible difference in domains */
 function checkCompatibility(
-    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
-    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+  mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+  secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>,
 ): boolean {
-    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
-    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
-    return secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id)));
+  const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+  const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+  return secondaryAxesIds.every((id) => mainAxesIds.some((mainId) => matchAxisId(mainId, id)));
 }
 
 export const IS_VIRTUAL_COLUMN = 'pl7.app/graph/isVirtual'; // annotation for column duplicates with extended domains
@@ -67,157 +69,157 @@ export const LABEL_ANNOTATION = 'pl7.app/label';
 /** Main column can have additional domains, if secondary column (meta-column) has all axes match main column axes
  we can add its copy with missed domain fields for compatibility */
 function getAdditionalColumnsForPair(
-    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
-    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+  mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+  secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>,
 ): PColumn<TreeNodeAccessor | PColumnValues>[] {
-    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
-    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
-
-    const isFullCompatible = checkFullCompatibility(mainColumn, secondaryColumn);
-    if (isFullCompatible) { // in this case it isn't necessary to add more columns
-        return [];
-    }
-    const isCompatible = checkCompatibility(mainColumn, secondaryColumn);
-    if (!isCompatible) { // in this case it is impossible to add some compatible column
-        return [];
-    }
-    // options with different possible domains for every axis of secondary column
-    const secondaryIdsOptions = secondaryAxesIds.map(id => {
-        return mainAxesIds.filter(mainId => matchAxisId(mainId, id));
-    });
+  const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+  const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+
+  const isFullCompatible = checkFullCompatibility(mainColumn, secondaryColumn);
+  if (isFullCompatible) { // in this case it isn't necessary to add more columns
+    return [];
+  }
+  const isCompatible = checkCompatibility(mainColumn, secondaryColumn);
+  if (!isCompatible) { // in this case it is impossible to add some compatible column
+    return [];
+  }
+  // options with different possible domains for every axis of secondary column
+  const secondaryIdsOptions = secondaryAxesIds.map((id) => {
+    return mainAxesIds.filter((mainId) => matchAxisId(mainId, id));
+  });
     // all possible combinations of axes with added domains
-    const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
-
-    // sets of added to column domain fields
-    const allAddedDomainValues = new Set<string>();
-    const addedNotToAllVariantsDomainValues = new Set<string>();
-    const addedByVariantsDomainValues = secondaryIdsVariants.map(idsList => {
-        const addedSet = new Set<string>();
-        idsList.map((axisId, idx) => {
-            const d1 = secondaryColumn.spec.axesSpec[idx].domain;
-            const d2 = axisId.domain;
-            Object.entries(d2 ?? {}).forEach(([key, value]) => {
-                if (d1?.[key] === undefined) {
-                    const item = JSON.stringify([key, value]);
-                    addedSet.add(item);
-                    allAddedDomainValues.add(item);
-                }
-            });
-            return ({
-                ...axisId,
-                annotations: secondaryColumn.spec.axesSpec[idx].annotations
-            })
-        });
-        return addedSet;
-    });
-    [...allAddedDomainValues].forEach(addedPart => {
-        if (addedByVariantsDomainValues.some(s => !s.has(addedPart))) {
-            addedNotToAllVariantsDomainValues.add(addedPart);
+  const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
+
+  // sets of added to column domain fields
+  const allAddedDomainValues = new Set<string>();
+  const addedNotToAllVariantsDomainValues = new Set<string>();
+  const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
+    const addedSet = new Set<string>();
+    idsList.map((axisId, idx) => {
+      const d1 = secondaryColumn.spec.axesSpec[idx].domain;
+      const d2 = axisId.domain;
+      Object.entries(d2 ?? {}).forEach(([key, value]) => {
+        if (d1?.[key] === undefined) {
+          const item = JSON.stringify([key, value]);
+          addedSet.add(item);
+          allAddedDomainValues.add(item);
         }
-    })
-
-    return secondaryIdsVariants.map((idsList, idx) => {
-        const id = colId(secondaryColumn.id, idsList.map(id => id.domain));
-
-        const label = secondaryColumn.spec.annotations?.[LABEL_ANNOTATION] ?? '';
-        const labelDomainPart = ([...addedByVariantsDomainValues[idx]])
-            .filter(str => addedNotToAllVariantsDomainValues.has(str))
-            .sort()
-            .map((v) => JSON.parse(v)?.[1]) // use in labels only domain values, but sort them by key to save the same order in all column variants
-            .join(' / ');
-
-        const annotations:Record<string, string> = {
-            ...secondaryColumn.spec.annotations,
-            [IS_VIRTUAL_COLUMN]: 'true'
-        }
-        if (label || labelDomainPart) {
-            annotations[LABEL_ANNOTATION] = label && labelDomainPart ? label + ' / ' + labelDomainPart : label + labelDomainPart;
-        }
-
-        return {
-            id: id as PObjectId,
-            spec: {
-                ...secondaryColumn.spec,
-                axesSpec: idsList.map((axisId, idx) => ({
-                    ...axisId,
-                    annotations: secondaryColumn.spec.axesSpec[idx].annotations
-                })),
-                annotations
-            },
-            data: secondaryColumn.data
-        };
+      });
+      return ({
+        ...axisId,
+        annotations: secondaryColumn.spec.axesSpec[idx].annotations,
+      });
     });
+    return addedSet;
+  });
+  [...allAddedDomainValues].forEach((addedPart) => {
+    if (addedByVariantsDomainValues.some((s) => !s.has(addedPart))) {
+      addedNotToAllVariantsDomainValues.add(addedPart);
+    }
+  });
+
+  return secondaryIdsVariants.map((idsList, idx) => {
+    const id = colId(secondaryColumn.id, idsList.map((id) => id.domain));
+
+    const label = secondaryColumn.spec.annotations?.[LABEL_ANNOTATION] ?? '';
+    const labelDomainPart = ([...addedByVariantsDomainValues[idx]])
+      .filter((str) => addedNotToAllVariantsDomainValues.has(str))
+      .sort()
+      .map((v) => JSON.parse(v)?.[1]) // use in labels only domain values, but sort them by key to save the same order in all column variants
+      .join(' / ');
+
+    const annotations: Record<string, string> = {
+      ...secondaryColumn.spec.annotations,
+      [IS_VIRTUAL_COLUMN]: 'true',
+    };
+    if (label || labelDomainPart) {
+      annotations[LABEL_ANNOTATION] = label && labelDomainPart ? label + ' / ' + labelDomainPart : label + labelDomainPart;
+    }
+
+    return {
+      id: id as PObjectId,
+      spec: {
+        ...secondaryColumn.spec,
+        axesSpec: idsList.map((axisId, idx) => ({
+          ...axisId,
+          annotations: secondaryColumn.spec.axesSpec[idx].annotations,
+        })),
+        annotations,
+      },
+      data: secondaryColumn.data,
+    };
+  });
 }
 
 export function getAdditionalColumns(columns: PColumn<TreeNodeAccessor | PColumnValues>[]): PColumn<TreeNodeAccessor | PColumnValues>[] {
-    const additionalColumns: PColumn<TreeNodeAccessor | PColumnValues>[] = [];
-    for (let i = 0; i < columns.length; i++) {
-        for (let j = i + 1; j < columns.length; j++) {
-            const column1 = columns[i];
-            const column2 = columns[j];
-
-            // check if column 1 is meta for column 2 or backward
-            additionalColumns.push(
-                ...getAdditionalColumnsForPair(column1, column2),
-                ...getAdditionalColumnsForPair(column2, column1)
-            );
-        }
+  const additionalColumns: PColumn<TreeNodeAccessor | PColumnValues>[] = [];
+  for (let i = 0; i < columns.length; i++) {
+    for (let j = i + 1; j < columns.length; j++) {
+      const column1 = columns[i];
+      const column2 = columns[j];
+
+      // check if column 1 is meta for column 2 or backward
+      additionalColumns.push(
+        ...getAdditionalColumnsForPair(column1, column2),
+        ...getAdditionalColumnsForPair(column2, column1),
+      );
     }
-    return additionalColumns;
+  }
+  return additionalColumns;
 }
 
 export function enrichColumnsWithCompatible(
-    mainColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
-    secondaryColumns: PColumn<TreeNodeAccessor | PColumnValues>[]
+  mainColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
+  secondaryColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
 ): PColumn<TreeNodeAccessor | PColumnValues>[] {
-    const result = [...mainColumns];
-    for (const secondaryColumn of secondaryColumns) {
-        for (const mainColumn of mainColumns) {
-            if (mainColumn.id === secondaryColumn.id) {
-                break;
-            }
-            if (checkCompatibility(mainColumn, secondaryColumn)) {
-                result.push(secondaryColumn);
-                break;
-            }
-        }
+  const result = [...mainColumns];
+  for (const secondaryColumn of secondaryColumns) {
+    for (const mainColumn of mainColumns) {
+      if (mainColumn.id === secondaryColumn.id) {
+        break;
+      }
+      if (checkCompatibility(mainColumn, secondaryColumn)) {
+        result.push(secondaryColumn);
+        break;
+      }
     }
-    return result;
+  }
+  return result;
 }
 
 const VALUE_TYPES: ValueType[] = [
-    'Int',
-    'Long',
-    'Float',
-    'Double',
-    'String',
-    'Bytes'
+  'Int',
+  'Long',
+  'Float',
+  'Double',
+  'String',
+  'Bytes',
 ];
 
 export function createPFrameForGraphs<A, U>(
-    ctx: RenderCtx<A, U>,
-    blockColumns?: PColumn<TreeNodeAccessor | PColumnValues>[]
+  ctx: RenderCtx<A, U>,
+  blockColumns?: PColumn<TreeNodeAccessor | PColumnValues>[],
 ): PFrameHandle | undefined {
-    if (blockColumns === undefined) return undefined;
+  if (blockColumns === undefined) return undefined;
 
-    const upstreamColumns = ctx.resultPool
-        .getData()
-        .entries.map((v) => v.obj)
-        .filter(isPColumn)
-        .filter((column) => VALUE_TYPES.includes(column.spec.valueType));
+  const upstreamColumns = ctx.resultPool
+    .getData()
+    .entries.map((v) => v.obj)
+    .filter(isPColumn)
+    .filter((column) => VALUE_TYPES.includes(column.spec.valueType));
 
-    const columnsWithCompatibleFromUpstream = enrichColumnsWithCompatible(blockColumns, upstreamColumns);
+  const columnsWithCompatibleFromUpstream = enrichColumnsWithCompatible(blockColumns, upstreamColumns);
 
-    // additional columns are duplicates with extra fields in domains for compatibility in all possible pairs of columns set
-    const extendedColumns = [...columnsWithCompatibleFromUpstream, ...getAdditionalColumns(columnsWithCompatibleFromUpstream)];
+  // additional columns are duplicates with extra fields in domains for compatibility in all possible pairs of columns set
+  const extendedColumns = [...columnsWithCompatibleFromUpstream, ...getAdditionalColumns(columnsWithCompatibleFromUpstream)];
 
-    // if at least one column is not yet ready, we can't show the table
-    if (
-        extendedColumns.some(
-            (a) => a.data instanceof TreeNodeAccessor && !a.data.getIsReadyOrError()
-        )
+  // if at least one column is not yet ready, we can't show the table
+  if (
+    extendedColumns.some(
+      (a) => a.data instanceof TreeNodeAccessor && !a.data.getIsReadyOrError(),
     )
-        return undefined;
+  )
+    return undefined;
 
-    return ctx.createPFrame(extendedColumns);
-}
+  return ctx.createPFrame(extendedColumns);
+}