@platforma-sdk/model 1.53.10 → 1.53.13

package/src/render/api.ts

@@ -24,7 +24,7 @@ import type {
   ResultCollection,
   SUniversalPColumnId,
   ValueOrError,
-} from '@milaboratories/pl-model-common';
+} from "@milaboratories/pl-model-common";
 import {
   AnchoredIdDeriver,
   ensurePColumn,
@@ -41,22 +41,29 @@ import {
   readAnnotation,
   selectorsToPredicate,
   withEnrichments,
-} from '@milaboratories/pl-model-common';
-import canonicalize from 'canonicalize';
-import type { Optional } from 'utility-types';
-import { getCfgRenderCtx } from '../internal';
-import { TreeNodeAccessor, ifDef } from './accessor';
-import type { FutureRef } from './future';
-import type { AccessorHandle, GlobalCfgRenderCtx } from './internal';
-import { MainAccessorName, StagingAccessorName } from './internal';
-import { PColumnCollection, type AxisLabelProvider, type ColumnProvider } from './util/column_collection';
-import type { LabelDerivationOps } from './util/label';
-import { deriveLabels } from './util/label';
-import type { APColumnSelectorWithSplit } from './util/split_selectors';
-import { patchInSetFilters } from './util/pframe_upgraders';
-import { allPColumnsReady } from './util';
-
-export type PColumnDataUniversal<TreeEntry = TreeNodeAccessor> = TreeEntry | DataInfo<TreeEntry> | PColumnValues;
+} from "@milaboratories/pl-model-common";
+import canonicalize from "canonicalize";
+import type { Optional } from "utility-types";
+import { getCfgRenderCtx } from "../internal";
+import { TreeNodeAccessor, ifDef } from "./accessor";
+import type { FutureRef } from "./future";
+import type { AccessorHandle, GlobalCfgRenderCtx } from "./internal";
+import { MainAccessorName, StagingAccessorName } from "./internal";
+import {
+  PColumnCollection,
+  type AxisLabelProvider,
+  type ColumnProvider,
+} from "./util/column_collection";
+import type { LabelDerivationOps } from "./util/label";
+import { deriveLabels } from "./util/label";
+import type { APColumnSelectorWithSplit } from "./util/split_selectors";
+import { patchInSetFilters } from "./util/pframe_upgraders";
+import { allPColumnsReady } from "./util";
+
+export type PColumnDataUniversal<TreeEntry = TreeNodeAccessor> =
+  | TreeEntry
+  | DataInfo<TreeEntry>
+  | PColumnValues;
 
 /**
  * Helper function to match domain objects
@@ -138,18 +145,19 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
     predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[],
     opts?: GetOptionsOpts | ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps,
   ): Option[] {
-    const predicate = typeof predicateOrSelector === 'function'
-      ? predicateOrSelector
-      : selectorsToPredicate(predicateOrSelector);
+    const predicate =
+      typeof predicateOrSelector === "function"
+        ? predicateOrSelector
+        : selectorsToPredicate(predicateOrSelector);
     const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
 
     let labelOps: LabelDerivationOps | ((spec: PObjectSpec, ref: PlRef) => string) = {};
     let refsWithEnrichments: boolean = false;
-    if (typeof opts !== 'undefined') {
-      if (typeof opts === 'function') {
+    if (typeof opts !== "undefined") {
+      if (typeof opts === "function") {
         labelOps = opts;
-      } else if (typeof opts === 'object') {
-        if ('includeNativeLabel' in opts || 'separator' in opts || 'addLabelAsSuffix' in opts) {
+      } else if (typeof opts === "object") {
+        if ("includeNativeLabel" in opts || "separator" in opts || "addLabelAsSuffix" in opts) {
           labelOps = opts;
         } else {
           opts = opts as GetOptionsOpts;
@@ -159,11 +167,13 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
       }
     }
 
-    if (typeof labelOps === 'object')
-      return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(({ value: { ref }, label }) => ({
-        ref: withEnrichments(ref, refsWithEnrichments),
-        label,
-      }));
+    if (typeof labelOps === "object")
+      return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(
+        ({ value: { ref }, label }) => ({
+          ref: withEnrichments(ref, refsWithEnrichments),
+          label,
+        }),
+      );
     else
       return filtered.map(({ ref, obj }) => ({
         ref: withEnrichments(ref, refsWithEnrichments),
@@ -171,14 +181,15 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
       }));
   }
 
-  public resolveAnchorCtx(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>): AnchoredIdDeriver | undefined {
+  public resolveAnchorCtx(
+    anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,
+  ): AnchoredIdDeriver | undefined {
     if (anchorsOrCtx instanceof AnchoredIdDeriver) return anchorsOrCtx;
     const resolvedAnchors: Record<string, PColumnSpec> = {};
     for (const [key, value] of Object.entries(anchorsOrCtx)) {
       if (isPlRef(value)) {
         const resolvedSpec = this.getPColumnSpecByRef(value);
-        if (!resolvedSpec)
-          return undefined;
+        if (!resolvedSpec) return undefined;
         resolvedAnchors[key] = resolvedSpec;
       } else {
         resolvedAnchors[key] = value;
@@ -197,7 +208,10 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
    */
   public getAnchoredPColumns(
     anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,
-    predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[],
+    predicateOrSelectors:
+      | ((spec: PColumnSpec) => boolean)
+      | APColumnSelectorWithSplit
+      | APColumnSelectorWithSplit[],
     opts?: UniversalPColumnOpts,
   ): PColumn<PColumnDataUniversal>[] | undefined {
     const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
@@ -242,7 +256,10 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
    */
   getCanonicalOptions(
     anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,
-    predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[],
+    predicateOrSelectors:
+      | ((spec: PColumnSpec) => boolean)
+      | APColumnSelectorWithSplit
+      | APColumnSelectorWithSplit[],
     opts?: UniversalPColumnOpts,
   ): { label: string; value: SUniversalPColumnId }[] | undefined {
     const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
@@ -286,13 +303,13 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
    * @deprecated use getDataWithErrors()
    */
   public getDataWithErrorsFromResultPool(): ResultCollection<
-    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, 'id'>
+    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">
   > {
     return this.getDataWithErrors();
   }
 
   public getDataWithErrors(): ResultCollection<
-    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, 'id'>
+    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">
   > {
     const result = this.ctx.getDataWithErrorsFromResultPool();
     return {
@@ -327,17 +344,14 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
    */
   public getDataByRef(ref: PlRef): PObject<TreeNodeAccessor> | undefined {
     // @TODO remove after 1 Jan 2025; forward compatibility
-    if (typeof this.ctx.getDataFromResultPoolByRef === 'undefined')
+    if (typeof this.ctx.getDataFromResultPoolByRef === "undefined")
       return this.getData().entries.find(
         (f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name,
       )?.obj;
     const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name); // Keep original call
     // Need to handle undefined case before mapping
     if (!data) return undefined;
-    return mapPObjectData(
-      data,
-      (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]),
-    );
+    return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));
   }
 
   /**
@@ -432,13 +446,13 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
 
       const spec = column.obj.spec;
       if (
-        spec.name === PColumnName.Label
-        && spec.axesSpec.length === 1
-        && spec.axesSpec[0].name === axis.name
-        && spec.axesSpec[0].type === axis.type
-        && matchDomain(axis.domain, spec.axesSpec[0].domain)
+        spec.name === PColumnName.Label &&
+        spec.axesSpec.length === 1 &&
+        spec.axesSpec[0].name === axis.name &&
+        spec.axesSpec[0].type === axis.type &&
+        matchDomain(axis.domain, spec.axesSpec[0].domain)
       ) {
-        if (column.obj.data.resourceType.name !== 'PColumnData/Json') {
+        if (column.obj.data.resourceType.name !== "PColumnData/Json") {
           throw Error(`Expected JSON column for labels, got: ${column.obj.data.resourceType.name}`);
         }
         const labels: Record<string | number, string> = Object.fromEntries(
@@ -465,7 +479,7 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
   public selectColumns(
     selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[],
   ): PColumn<TreeNodeAccessor | undefined>[] {
-    const predicate = typeof selectors === 'function' ? selectors : selectorsToPredicate(selectors);
+    const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
 
     const matchedSpecs = this.getSpecs().entries.filter(({ obj: spec }) => {
       if (!isPColumnSpec(spec)) return false;
@@ -499,15 +513,20 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
    * Find labels data for a given axis id of a p-column.
    * @returns a map of axis value => label
    */
-  public findLabelsForColumnAxis(column: PColumnSpec, axisIdx: number): Record<string | number, string> | undefined {
+  public findLabelsForColumnAxis(
+    column: PColumnSpec,
+    axisIdx: number,
+  ): Record<string | number, string> | undefined {
     const labels = this.findLabels(column.axesSpec[axisIdx]);
     if (!labels) return undefined;
     const axisKeys = readAnnotation(column, `pl7.app/axisKeys/${axisIdx}`);
     if (axisKeys !== undefined) {
       const keys = JSON.parse(axisKeys) as string[];
-      return Object.fromEntries(keys.map((key) => {
-        return [key, labels[key] ?? 'Unlabelled'];
-      }));
+      return Object.fromEntries(
+        keys.map((key) => {
+          return [key, labels[key] ?? "Unlabelled"];
+        }),
+      );
     } else {
       return labels;
     }
@@ -527,7 +546,7 @@ export abstract class RenderCtxBase<Args, Data> {
   public get data(): Data {
     if (this._dataCache === undefined) {
       const raw = this.ctx.data;
-      const value = typeof raw === 'function' ? raw() : raw;
+      const value = typeof raw === "function" ? raw() : raw;
       this._dataCache = { v: value ? JSON.parse(value) : ({} as Data) };
     }
     return this._dataCache.v;
@@ -543,7 +562,7 @@ export abstract class RenderCtxBase<Args, Data> {
   public get activeArgs(): Args | undefined {
     if (this._activeArgsCache === undefined) {
       const raw = this.ctx.activeArgs;
-      const value = typeof raw === 'function' ? raw() : raw;
+      const value = typeof raw === "function" ? raw() : raw;
       this._activeArgsCache = {
         v: value ? JSON.parse(value) : undefined,
       };
@@ -582,15 +601,22 @@ export abstract class RenderCtxBase<Args, Data> {
     return this.resultPool.findLabels(axis);
   }
 
-  private verifyInlineAndExplicitColumnsSupport(columns: (PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>)[]) {
-    const hasInlineColumns = columns.some((c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data)); // Updated check for DataInfo
+  private verifyInlineAndExplicitColumnsSupport(
+    columns: (PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>)[],
+  ) {
+    const hasInlineColumns = columns.some(
+      (c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data),
+    ); // Updated check for DataInfo
     const inlineColumnsSupport = this.ctx.featureFlags?.inlineColumnsSupport === true;
-    if (hasInlineColumns && !inlineColumnsSupport) throw Error(`Inline or explicit columns not supported`); // Combined check
+    if (hasInlineColumns && !inlineColumnsSupport)
+      throw Error(`Inline or explicit columns not supported`); // Combined check
 
     // Removed redundant explicitColumns check
   }
 
-  private patchPTableDef(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableDef<PColumn<PColumnDataUniversal>> {
+  private patchPTableDef(
+    def: PTableDef<PColumn<PColumnDataUniversal>>,
+  ): PTableDef<PColumn<PColumnDataUniversal>> {
     if (!this.ctx.featureFlags?.pTablePartitionFiltersSupport) {
       // For old desktop move all partition filters to filters field as it doesn't read partitionFilters field
       def = {
@@ -610,12 +636,12 @@ export abstract class RenderCtxBase<Args, Data> {
   }
 
   // TODO remove all non-PColumn fields
-  public createPFrame(def: PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>>): PFrameHandle | undefined {
+  public createPFrame(
+    def: PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>>,
+  ): PFrameHandle | undefined {
     this.verifyInlineAndExplicitColumnsSupport(def);
     if (!allPColumnsReady(def)) return undefined;
-    return this.ctx.createPFrame(
-      def.map((c) => transformPColumnData(c)),
-    );
+    return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
   }
 
   // TODO remove all non-PColumn fields
@@ -630,18 +656,18 @@ export abstract class RenderCtxBase<Args, Data> {
     def:
       | PTableDef<PColumn<PColumnDataUniversal>>
       | {
-        columns: PColumn<PColumnDataUniversal>[];
-        filters?: PTableRecordFilter[];
-        /** Table sorting */
-        sorting?: PTableSorting[];
-      },
+          columns: PColumn<PColumnDataUniversal>[];
+          filters?: PTableRecordFilter[];
+          /** Table sorting */
+          sorting?: PTableSorting[];
+        },
   ): PTableHandle | undefined {
     let rawDef: PTableDef<PColumn<PColumnDataUniversal>>;
-    if ('columns' in def) {
+    if ("columns" in def) {
       rawDef = this.patchPTableDef({
         src: {
-          type: 'full',
-          entries: def.columns.map((c) => ({ type: 'column', column: c })),
+          type: "full",
+          entries: def.columns.map((c) => ({ type: "column", column: c })),
         },
         partitionFilters: def.filters ?? [],
         filters: [],
@@ -653,9 +679,7 @@ export abstract class RenderCtxBase<Args, Data> {
     const columns = extractAllColumns(rawDef.src);
     this.verifyInlineAndExplicitColumnsSupport(columns);
     if (!allPColumnsReady(columns)) return undefined;
-    return this.ctx.createPTable(
-      mapPTableDef(rawDef, (po) => transformPColumnData(po)),
-    );
+    return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
   }
 
   /** @deprecated scheduled for removal from SDK */
@@ -686,7 +710,7 @@ export class RenderCtx<Args, Data> extends RenderCtxBase<Args, Data> {
   public get args(): Args | undefined {
     if (this._argsCache === undefined) {
       const raw = this.ctx.args;
-      const value = typeof raw === 'function' ? raw() : raw;
+      const value = typeof raw === "function" ? raw() : raw;
       // args can be undefined when derivation fails (e.g., validation error in args())
       this._argsCache = { v: value === undefined ? undefined : JSON.parse(value) };
     }
@@ -700,7 +724,7 @@ export class RenderCtxLegacy<Args, UiState> extends RenderCtxBase<Args, UiState>
   public get args(): Args {
     if (this._argsCache === undefined) {
       const raw = this.ctx.args;
-      const value = typeof raw === 'function' ? raw() : raw;
+      const value = typeof raw === "function" ? raw() : raw;
       this._argsCache = { v: JSON.parse(value) };
     }
     return this._argsCache.v;
@@ -711,7 +735,7 @@ export class RenderCtxLegacy<Args, UiState> extends RenderCtxBase<Args, UiState>
   public get uiState(): UiState {
     if (this._uiStateCache === undefined) {
       const raw = this.ctx.uiState!;
-      const value = typeof raw === 'function' ? raw() : raw;
+      const value = typeof raw === "function" ? raw() : raw;
       this._uiStateCache = { v: value ? JSON.parse(value) : ({} as UiState) };
     }
     return this._uiStateCache.v;
@@ -719,11 +743,11 @@ export class RenderCtxLegacy<Args, UiState> extends RenderCtxBase<Args, UiState>
 }
 
 export type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (
-  rCtx: RenderCtx<Args, State>
+  rCtx: RenderCtx<Args, State>,
 ) => Ret;
 
 export type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (
-  rCtx: RenderCtxLegacy<Args, State>
+  rCtx: RenderCtxLegacy<Args, State>,
 ) => Ret;
 
 export type UnwrapFutureRef<K> =

package/src/render/future.ts

@@ -1,5 +1,5 @@
-import type { FutureAwait, FutureHandle } from './internal';
-import { registerFutureAwait } from '../internal';
+import type { FutureAwait, FutureHandle } from "./internal";
+import { registerFutureAwait } from "../internal";
 
 export class FutureRef<T = unknown> {
   private isResolved = false;

package/src/render/index.ts

@@ -1,6 +1,6 @@
-export * from './api';
-export * from './traversal_ops';
-export * from './accessor';
-export * from './util';
-export { type ExtractFutureRefType } from './future';
-export { FutureRef } from './future';
+export * from "./api";
+export * from "./traversal_ops";
+export * from "./accessor";
+export * from "./util";
+export { type ExtractFutureRefType } from "./future";
+export { FutureRef } from "./future";

package/src/render/internal.ts

@@ -1,6 +1,6 @@
-import type { Optional } from 'utility-types';
-import type { Branded } from '../branding';
-import type { CommonFieldTraverseOps, FieldTraversalStep, ResourceType } from './traversal_ops';
+import type { Optional } from "utility-types";
+import type { Branded } from "../branding";
+import type { CommonFieldTraverseOps, FieldTraversalStep, ResourceType } from "./traversal_ops";
 import type {
   ArchiveFormat,
   AnyFunction,
@@ -18,16 +18,15 @@ import type {
   ValueOrError,
   DataInfo,
   RangeBytes,
-} from '@milaboratories/pl-model-common';
+} from "@milaboratories/pl-model-common";
 
-export const StagingAccessorName = 'staging';
-export const MainAccessorName = 'main';
+export const StagingAccessorName = "staging";
+export const MainAccessorName = "main";
 
-export type AccessorHandle = Branded<string, 'AccessorHandle'>;
-export type FutureHandle = Branded<string, 'FutureHandle'>;
+export type AccessorHandle = Branded<string, "AccessorHandle">;
+export type FutureHandle = Branded<string, "FutureHandle">;
 
 export interface GlobalCfgRenderCtxMethods<AHandle = AccessorHandle, FHandle = FutureHandle> {
-
   //
   // Root accessor creation
   //
@@ -128,7 +127,7 @@ export interface GlobalCfgRenderCtxMethods<AHandle = AccessorHandle, FHandle = F
   getDataFromResultPool(): ResultCollection<PObject<AHandle>>;
 
   getDataWithErrorsFromResultPool(): ResultCollection<
-    Optional<PObject<ValueOrError<AHandle, Error>>, 'id'>
+    Optional<PObject<ValueOrError<AHandle, Error>>, "id">
   >;
 
   getSpecsFromResultPool(): ResultCollection<PObjectSpec>;
@@ -200,7 +199,7 @@ export type FutureAwait = {
 };
 
 export function isFutureAwait(obj: unknown): obj is FutureAwait {
-  return typeof obj === 'object' && obj !== null && '__awaited_futures__' in obj;
+  return typeof obj === "object" && obj !== null && "__awaited_futures__" in obj;
 }
 
 function addAllFutureAwaits(set: Set<string>, visited: Set<unknown>, node: unknown) {
@@ -208,7 +207,7 @@ function addAllFutureAwaits(set: Set<string>, visited: Set<unknown>, node: unkno
   visited.add(node);
 
   const type = typeof node;
-  if (type === 'object') {
+  if (type === "object") {
     if (isFutureAwait(node)) node.__awaited_futures__.forEach((a) => set.add(a));
     else if (Array.isArray(node))
       for (const nested of node) addAllFutureAwaits(set, visited, nested);

package/src/render/traversal_ops.ts

@@ -20,7 +20,7 @@ export type CommonFieldTraverseOps = {
   stableIfNotFound?: true;
 };
 
-export type FieldType = 'Input' | 'Output' | 'Service' | 'OTW' | 'Dynamic' | 'MTW';
+export type FieldType = "Input" | "Output" | "Service" | "OTW" | "Dynamic" | "MTW";
 
 export interface ResourceType {
   readonly name: string;

package/src/render/util/axis_filtering.ts

@@ -9,8 +9,8 @@ import type {
   BinaryPartitionedDataInfoEntries,
   ParquetPartitionedDataInfoEntries,
   PartitionedDataInfoEntries,
-} from '@milaboratories/pl-model-common';
-import type { AxisFilterByIdx } from '@milaboratories/pl-model-common';
+} from "@milaboratories/pl-model-common";
+import type { AxisFilterByIdx } from "@milaboratories/pl-model-common";
 
 /**
  * Filters DataInfoEntries using axis filters, removing specified axes from keys and
@@ -50,20 +50,22 @@ export function filterDataInfoEntries<Blob>(
   // Check for invalid filter axes
   const { type } = dataInfoEntries;
   switch (type) {
-    case 'Json': {
+    case "Json": {
       const { keyLength } = dataInfoEntries;
       for (const [axisIdx] of axisFilters)
         if (axisIdx >= keyLength)
           throw new Error(`Can't filter on non-data axis ${axisIdx}. Must be >= ${keyLength}`);
       break;
     }
-    case 'JsonPartitioned':
-    case 'BinaryPartitioned':
-    case 'ParquetPartitioned': {
+    case "JsonPartitioned":
+    case "BinaryPartitioned":
+    case "ParquetPartitioned": {
       const { partitionKeyLength } = dataInfoEntries;
       for (const [axisIdx] of axisFilters)
         if (axisIdx >= partitionKeyLength)
-          throw new Error(`Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`);
+          throw new Error(
+            `Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`,
+          );
       break;
     }
     default:
@@ -72,9 +74,7 @@ export function filterDataInfoEntries<Blob>(
   }
 
   const keyMatchesFilters = (key: PColumnKey): boolean => {
-    for (const [axisIdx, axisValue] of sortedFilters)
-      if (key[axisIdx] !== axisValue)
-        return false;
+    for (const [axisIdx, axisValue] of sortedFilters) if (key[axisIdx] !== axisValue) return false;
     return true;
   };
 
@@ -82,52 +82,67 @@ export function filterDataInfoEntries<Blob>(
     const newKey = [...key];
 
     // Remove axes in descending order to maintain correct indices
-    for (const [axisIdx] of sortedFilters)
-      newKey.splice(axisIdx, 1);
+    for (const [axisIdx] of sortedFilters) newKey.splice(axisIdx, 1);
 
     return newKey;
   };
 
   switch (dataInfoEntries.type) {
-    case 'Json': return {
-      type: 'Json',
-      keyLength: dataInfoEntries.keyLength - axisFilters.length,
-      data: dataInfoEntries.data
-        .filter((entry) => keyMatchesFilters(entry.key))
-        .map((entry) => ({
-          key: removeFilteredAxes(entry.key),
-          value: entry.value,
-        } satisfies PColumnDataEntry<PColumnValue>)),
-    };
-    case 'JsonPartitioned': return {
-      type: 'JsonPartitioned',
-      partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-      parts: dataInfoEntries.parts
-        .filter((entry) => keyMatchesFilters(entry.key))
-        .map((entry) => ({
-          key: removeFilteredAxes(entry.key),
-          value: entry.value,
-        } satisfies PColumnDataEntry<Blob>)),
-    };
-    case 'BinaryPartitioned': return {
-      type: 'BinaryPartitioned',
-      partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-      parts: dataInfoEntries.parts
-        .filter((entry) => keyMatchesFilters(entry.key))
-        .map((entry) => ({
-          key: removeFilteredAxes(entry.key),
-          value: entry.value,
-        } satisfies PColumnDataEntry<BinaryChunk<Blob>>)),
-    };
-    case 'ParquetPartitioned': return {
-      type: 'ParquetPartitioned',
-      partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-      parts: dataInfoEntries.parts
-        .filter((entry) => keyMatchesFilters(entry.key))
-        .map((entry) => ({
-          key: removeFilteredAxes(entry.key),
-          value: entry.value,
-        } satisfies PColumnDataEntry<Blob>)),
-    };
+    case "Json":
+      return {
+        type: "Json",
+        keyLength: dataInfoEntries.keyLength - axisFilters.length,
+        data: dataInfoEntries.data
+          .filter((entry) => keyMatchesFilters(entry.key))
+          .map(
+            (entry) =>
+              ({
+                key: removeFilteredAxes(entry.key),
+                value: entry.value,
+              }) satisfies PColumnDataEntry<PColumnValue>,
+          ),
+      };
+    case "JsonPartitioned":
+      return {
+        type: "JsonPartitioned",
+        partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+        parts: dataInfoEntries.parts
+          .filter((entry) => keyMatchesFilters(entry.key))
+          .map(
+            (entry) =>
+              ({
+                key: removeFilteredAxes(entry.key),
+                value: entry.value,
+              }) satisfies PColumnDataEntry<Blob>,
+          ),
+      };
+    case "BinaryPartitioned":
+      return {
+        type: "BinaryPartitioned",
+        partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+        parts: dataInfoEntries.parts
+          .filter((entry) => keyMatchesFilters(entry.key))
+          .map(
+            (entry) =>
+              ({
+                key: removeFilteredAxes(entry.key),
+                value: entry.value,
+              }) satisfies PColumnDataEntry<BinaryChunk<Blob>>,
+          ),
+      };
+    case "ParquetPartitioned":
+      return {
+        type: "ParquetPartitioned",
+        partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+        parts: dataInfoEntries.parts
+          .filter((entry) => keyMatchesFilters(entry.key))
+          .map(
+            (entry) =>
+              ({
+                key: removeFilteredAxes(entry.key),
+                value: entry.value,
+              }) satisfies PColumnDataEntry<Blob>,
+          ),
+      };
   }
 }