@platforma-sdk/model 1.63.1 → 1.64.0

package/src/components/PlDataTable/createPlDataTable/discoverColumns.ts

@@ -0,0 +1,122 @@
+import type {
+  PColumnSpec,
+  PlRef,
+  PObjectId,
+  RequireServices,
+  Services,
+  SUniversalPColumnId,
+} from "@milaboratories/pl-model-common";
+import { isPlRef } from "@milaboratories/pl-model-common";
+import type { RenderCtxBase } from "../../../render";
+import type { ColumnSource, ColumnMatch, RelaxedColumnSelector } from "../../../columns";
+import { ColumnCollectionBuilder } from "../../../columns";
+import { toColumnSnapshotProvider } from "../../../columns/column_snapshot_provider";
+import { collectCtxColumnSnapshotProviders } from "../../../columns/ctx_column_sources";
+import { throwError } from "@milaboratories/helpers";
+import type { ColumnsSelectorConfig, TableColumnSnapshot } from "./createPlDataTableV3";
+
+export type DiscoveredTableColumnOptions = {
+  sources?: ColumnSource[];
+  anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>;
+  columnsSelector: ColumnsSelectorConfig;
+};
+
+/** Discover columns from sources/anchors and normalize into a flat DiscoveredColumn list. */
+export function discoverTableColumnSnaphots<
+  A,
+  U,
+  S extends RequireServices<typeof Services.PFrameSpec>,
+>(
+  ctx: RenderCtxBase<A, U, S>,
+  options: DiscoveredTableColumnOptions,
+): TableColumnSnapshot<SUniversalPColumnId>[] | undefined {
+  // Resolve PlRef anchors to PColumnSpec
+  const resolvedOptions = { ...options, anchors: resolveAnchors(ctx, options.anchors) };
+
+  // Resolve providers
+  const providers = resolveProviders(ctx, resolvedOptions.sources);
+  if (providers.length === 0) return undefined;
+
+  // Build collection (anchored or plain)
+  const pframeSpec =
+    ctx.services.pframeSpec ?? throwError("PFrameSpec service is required for column discovery.");
+  const collection = new ColumnCollectionBuilder(pframeSpec)
+    .addSources(providers)
+    .build(resolvedOptions);
+  if (collection === undefined) return undefined;
+
+  try {
+    const matched = collection.findColumns(resolvedOptions.columnsSelector ?? undefined);
+    const anchors = collection.getAnchors();
+    return mapToDiscoveredColumns(
+      matched,
+      Array.from(Array.from(anchors.values()).map((v) => v.columnId)),
+    );
+  } finally {
+    collection.dispose();
+  }
+}
+
+// --- Pure helper functions ---
+
+/** Resolve PlRef values in anchors to PColumnSpec via the result pool. */
+function resolveAnchors<A, U>(
+  ctx: RenderCtxBase<A, U>,
+  anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>,
+): Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> {
+  const result: Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> = {};
+  for (const [key, value] of Object.entries(anchors)) {
+    if (isPlRef(value)) {
+      result[key] =
+        ctx.resultPool.getPColumnSpecByRef(value) ??
+        throwError(
+          `Anchor ${key} with ref ${JSON.stringify(value)} could not be resolved to a PColumnSpec`,
+        );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+/** Resolve column snapshot providers from explicit sources or context. */
+function resolveProviders<A, U>(ctx: RenderCtxBase<A, U>, sources: undefined | ColumnSource[]) {
+  return sources !== undefined
+    ? sources.map(toColumnSnapshotProvider)
+    : collectCtxColumnSnapshotProviders(ctx);
+}
+
+/** Map matched columns into a flat DiscoveredColumn list with deduped IDs. */
+function mapToDiscoveredColumns(
+  matched: readonly ColumnMatch[],
+  anchorColumnIds: readonly PObjectId[],
+): TableColumnSnapshot<SUniversalPColumnId>[] {
+  const hitCounts = matched.reduce(
+    (acc, match) => acc.set(match.originalId, (acc.get(match.originalId) ?? 0) + 1),
+    new Map<PObjectId, number>(),
+  );
+
+  const hitIndices = new Map<PObjectId, number>();
+  return matched.map((match) => {
+    const snap = match.column;
+
+    let id = snap.id;
+    if ((hitCounts.get(match.originalId) ?? 0) > 1) {
+      const idx = hitIndices.get(match.originalId) ?? 0;
+      hitIndices.set(match.originalId, idx + 1);
+      id = `${snap.id}#q${idx}` as SUniversalPColumnId;
+    }
+
+    return {
+      id,
+      originalId: match.originalId,
+      spec: snap.spec,
+      data: snap.data,
+      dataStatus: snap.dataStatus,
+      isPrimary: anchorColumnIds.some(
+        (anchor) => snap.id === anchor || match.originalId === anchor,
+      ),
+      linkerPath: match.path,
+    };
+  });
+}

package/src/components/PlDataTable/createPlDataTable/index.ts

@@ -5,8 +5,8 @@ import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataT
 import { createPlDataTableV3 } from "./createPlDataTableV3";
 import type { createPlDataTableOptionsV3 } from "./createPlDataTableV3";
 
-export function createPlDataTable<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options: { version: "v2" } & createPlDataTableOptionsV2,
 ): ReturnType<typeof createPlDataTableV2>;
 export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
@@ -26,3 +26,5 @@ export function createPlDataTable<A, U, S extends RequireServices<typeof Service
     return createPlDataTableV3(ctx, options);
   }
 }
+
+export { discoverTableColumnSnaphots } from "./discoverColumns";

package/src/components/PlDataTable/createPlDataTable/utils.test.ts

@@ -0,0 +1,257 @@
+import {
+  Annotation,
+  canonicalizeJson,
+  getAxisId,
+  type AxisId,
+  type PColumnSpec,
+  type PObjectId,
+} from "@milaboratories/pl-model-common";
+import { describe, expect, test } from "vitest";
+import { deriveAllLabels, type LabelableColumn } from "./utils";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSpec(overrides: Partial<PColumnSpec> = {}): PColumnSpec {
+  return {
+    kind: "PColumn",
+    name: "col",
+    valueType: "Int",
+    annotations: {},
+    axesSpec: [],
+    ...overrides,
+  } as PColumnSpec;
+}
+
+function makeLabelableColumn(
+  id: string,
+  spec: Partial<PColumnSpec> = {},
+  linkerPath?: LabelableColumn["linkerPath"],
+): LabelableColumn {
+  return {
+    id: id as PObjectId,
+    spec: makeSpec(spec),
+    linkerPath,
+  };
+}
+
+function makeLabelColumn(
+  axisSpec: PColumnSpec["axesSpec"][0],
+  label: string,
+): { readonly spec: PColumnSpec } {
+  return {
+    spec: makeSpec({
+      name: "label-col",
+      valueType: "String",
+      annotations: { [Annotation.Label]: label },
+      axesSpec: [axisSpec],
+    }),
+  };
+}
+
+function axisKey(axis: PColumnSpec["axesSpec"][0]): string {
+  return canonicalizeJson<AxisId>(getAxisId(axis));
+}
+
+// ---------------------------------------------------------------------------
+// deriveAllLabels
+// ---------------------------------------------------------------------------
+
+describe("deriveAllLabels", () => {
+  test("returns column labels derived from deriveDistinctLabels", () => {
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "alpha",
+        annotations: { [Annotation.Label]: "Alpha" },
+      }),
+      makeLabelableColumn("c2", {
+        name: "beta",
+        annotations: { [Annotation.Label]: "Beta" },
+      }),
+    ];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns: [],
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result["c1"]).toBe("Alpha");
+    expect(result["c2"]).toBe("Beta");
+  });
+
+  test("returns axis labels from label columns when available", () => {
+    const axis = { type: "String", name: "sample" } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "score",
+        axesSpec: [axis],
+        annotations: { [Annotation.Label]: "Score" },
+      }),
+    ];
+    const labelColumns = [makeLabelColumn(axis, "Sample Name")];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns,
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result[axisKey(axis)]).toBe("Sample Name");
+  });
+
+  test("falls back to axis annotation when no label column matches", () => {
+    const axis = { type: "String", name: "gene" } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "expr",
+        axesSpec: [{ ...axis, annotations: { [Annotation.Label]: "Gene ID" } }],
+        annotations: { [Annotation.Label]: "Expression" },
+      }),
+    ];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns: [],
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result[axisKey(axis)]).toBe("Gene ID");
+  });
+
+  test("axis with no label annotation and no label column gets 'Unlabeled'", () => {
+    const axis = { type: "Int", name: "idx" } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "val",
+        axesSpec: [axis],
+        annotations: { [Annotation.Label]: "Value" },
+      }),
+    ];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns: [],
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result[axisKey(axis)]).toBe("Unlabeled");
+  });
+
+  test("deduplicates axes shared across columns", () => {
+    const sharedAxis = { type: "String", name: "sample" } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "score1",
+        axesSpec: [sharedAxis],
+        annotations: { [Annotation.Label]: "Score 1" },
+      }),
+      makeLabelableColumn("c2", {
+        name: "score2",
+        axesSpec: [sharedAxis],
+        annotations: { [Annotation.Label]: "Score 2" },
+      }),
+    ];
+    const labelColumns = [makeLabelColumn(sharedAxis, "Sample")];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns,
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    // axis label appears once
+    expect(result[axisKey(sharedAxis)]).toBe("Sample");
+    // column labels are distinct
+    expect(result["c1"]).toBe("Score 1");
+    expect(result["c2"]).toBe("Score 2");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// deriveAxisLabels (tested through deriveAllLabels)
+// ---------------------------------------------------------------------------
+
+describe("deriveAxisLabels via deriveAllLabels", () => {
+  test("multiple axes each get their own label", () => {
+    const axis1 = { type: "String", name: "sample" } as const;
+    const axis2 = { type: "String", name: "chain" } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "value",
+        axesSpec: [axis1, axis2],
+        annotations: { [Annotation.Label]: "Value" },
+      }),
+    ];
+    const labelColumns = [
+      makeLabelColumn(axis1, "Sample ID"),
+      makeLabelColumn(axis2, "Chain Type"),
+    ];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns,
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result[axisKey(axis1)]).toBe("Sample ID");
+    expect(result[axisKey(axis2)]).toBe("Chain Type");
+  });
+
+  test("label column overrides axis annotation", () => {
+    const axis = {
+      type: "String",
+      name: "sample",
+      annotations: { [Annotation.Label]: "Axis Annotation Label" },
+    } as const;
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn("c1", {
+        name: "v",
+        axesSpec: [axis],
+        annotations: { [Annotation.Label]: "V" },
+      }),
+    ];
+    const labelColumns = [makeLabelColumn({ type: "String", name: "sample" }, "Label Col Label")];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns,
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result[axisKey(axis)]).toBe("Label Col Label");
+  });
+
+  // Regression: LabelableColumn.linkerPath used to be `linkerPath` while
+  // deriveDistinctLabels.Entry expected `linkersPath`. Structural typing +
+  // optional fields hid the mismatch from the type checker — the field flowed
+  // through as "extra" and disambiguation silently broke. This asserts the
+  // linker label reaches the output.
+  test("linkerPath flows into deriveDistinctLabels and produces the 'via' suffix", () => {
+    const linkerSpec = makeSpec({
+      name: "linker",
+      annotations: { [Annotation.LinkLabel]: "ClusterA" },
+    });
+    const columns: LabelableColumn[] = [
+      makeLabelableColumn(
+        "c1",
+        { name: "shared", annotations: { [Annotation.Label]: "Cluster size" } },
+        [{ spec: linkerSpec }],
+      ),
+      makeLabelableColumn("c2", {
+        name: "shared",
+        annotations: { [Annotation.Label]: "Cluster size" },
+      }),
+    ];
+
+    const result = deriveAllLabels({
+      columns,
+      labelColumns: [],
+      deriveLabelsOptions: { includeNativeLabel: true },
+    });
+
+    expect(result["c1"]).toContain("via ClusterA");
+    expect(result["c2"]).not.toContain("via ");
+  });
+});

package/src/components/PlDataTable/createPlDataTable/utils.ts

@@ -0,0 +1,160 @@
+import {
+  type PColumn,
+  type PColumnSpec,
+  type PObjectId,
+  Annotation,
+  canonicalizeAxisId,
+  canonicalizeJson,
+  getAxisId,
+  readAnnotation,
+  readAnnotationJson,
+} from "@milaboratories/pl-model-common";
+import {
+  deriveDistinctLabels,
+  type DeriveLabelsOptions,
+} from "../../../labels/derive_distinct_labels";
+import type { ColumnsDisplayOptions } from "./createPlDataTableV3";
+import { isNil } from "es-toolkit";
+
+/** Check if column should be omitted from the table */
+export function isColumnHidden(spec: { annotations?: Annotation }): boolean {
+  return readAnnotation(spec, Annotation.Table.Visibility) === "hidden";
+}
+
+/** Check if column is hidden by default */
+export function isColumnOptional(spec: { annotations?: Annotation }): boolean {
+  return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
+}
+
+/** Get effective visibility for a column, considering display config rules first, then annotations. */
+export function getEffectiveVisibility(
+  spec: PColumnSpec,
+  displayConfig?: ColumnsDisplayOptions,
+): undefined | "default" | "optional" | "hidden" {
+  if (displayConfig?.visibility) {
+    for (const rule of displayConfig.visibility) {
+      if (rule.match(spec)) {
+        return rule.visibility;
+      }
+    }
+  }
+  if (isColumnHidden(spec)) return "hidden";
+  if (isColumnOptional(spec)) return "optional";
+  return undefined;
+}
+
+/** Get ordering priority for a column. Display config rules first, then annotation fallback. */
+export function getOrderPriority(
+  spec: PColumnSpec,
+  displayConfig?: ColumnsDisplayOptions,
+): undefined | number {
+  if (displayConfig?.ordering) {
+    for (const rule of displayConfig.ordering) {
+      if (rule.match(spec)) {
+        return rule.priority;
+      }
+    }
+  }
+  return readAnnotationJson(spec, Annotation.Table.OrderPriority);
+}
+
+/**
+ * Writes derived labels into column and axis annotations.
+ * Returns new column objects with modified specs — original columns are not mutated.
+ *
+ * For each column: writes derived label into Annotation.Label (if present in derivedLabels).
+ * For each axis in column specs: writes derived axis label into AxisSpec annotations.
+ */
+export function withLabelAnnotations<Data>(
+  derivedLabels: undefined | Record<string, string>,
+  columns: PColumn<Data>[],
+): PColumn<Data>[] {
+  if (derivedLabels === undefined) return columns;
+  return columns.map((col) => {
+    const colLabel = derivedLabels[col.id];
+    return {
+      ...col,
+      spec: {
+        ...col.spec,
+        ...(isNil(colLabel)
+          ? {}
+          : { annotations: { ...col.spec.annotations, [Annotation.Label]: colLabel } }),
+        axesSpec: col.spec.axesSpec.map((axis) => {
+          const label = derivedLabels[canonicalizeAxisId(axis)];
+          return isNil(label)
+            ? axis
+            : { ...axis, annotations: { ...axis.annotations, [Annotation.Label]: label } };
+        }),
+      },
+    };
+  });
+}
+
+/**
+ * Writes effective display properties (OrderPriority, Visibility) from ColumnDisplayOptions
+ * into column annotations. Returns new column objects — originals are not mutated.
+ */
+export function withTableVisualAnnotations<Data>(
+  displayOptions: undefined | ColumnsDisplayOptions,
+  columns: PColumn<Data>[],
+): PColumn<Data>[] {
+  if (displayOptions === undefined) return columns;
+  return columns.map((col) => {
+    const annotations = { ...col.spec.annotations };
+
+    const visibility = getEffectiveVisibility(col.spec, displayOptions);
+    if (!isNil(visibility)) annotations[Annotation.Table.Visibility] = visibility;
+
+    const orderPriority = getOrderPriority(col.spec, displayOptions);
+    if (!isNil(orderPriority)) annotations[Annotation.Table.OrderPriority] = String(orderPriority);
+
+    return {
+      ...col,
+      spec: {
+        ...col.spec,
+        annotations: annotations,
+      },
+    };
+  });
+}
+
+/** Column shape required by label derivation. */
+export type LabelableColumn = {
+  readonly id: PObjectId;
+  readonly spec: PColumnSpec;
+  readonly linkerPath?: { spec: PColumnSpec }[];
+};
+
+/** Derive labels for all table elements: columns via deriveDistinctLabels, axes from label columns. */
+export function deriveAllLabels(options: {
+  columns: LabelableColumn[];
+  labelColumns: { readonly spec: PColumnSpec }[];
+  deriveLabelsOptions?: DeriveLabelsOptions;
+}): Record<string, string> {
+  const { columns, labelColumns, deriveLabelsOptions } = options;
+  const axisLabels = deriveAxisLabels(columns, labelColumns);
+  const columnLabels = deriveDistinctLabels(columns, deriveLabelsOptions).reduce(
+    (acc, label, index) => ((acc[columns[index].id] = label), acc),
+    {} as Record<string, string>,
+  );
+  return { ...axisLabels, ...columnLabels };
+}
+
+/** Derive axis labels from matching label columns, falling back to axis spec annotations. */
+function deriveAxisLabels(
+  columns: { readonly spec: PColumnSpec }[],
+  labelColumns: { readonly spec: PColumnSpec }[],
+): Record<string, string> {
+  const axisSpecMap = new Map(
+    columns.flatMap((c) => c.spec.axesSpec).map((a) => [canonicalizeJson(getAxisId(a)), a]),
+  );
+  const result: Record<string, string> = {};
+  for (const axisKey of axisSpecMap.keys()) {
+    const labelCol = labelColumns.find(
+      (lc) => canonicalizeJson(getAxisId(lc.spec.axesSpec[0])) === axisKey,
+    );
+    const source = labelCol?.spec ?? axisSpecMap.get(axisKey);
+    result[axisKey] = readAnnotation(source ?? {}, Annotation.Label)?.trim() ?? "Unlabeled";
+  }
+  return result;
+}

package/src/components/PlDataTable/index.ts

@@ -22,10 +22,21 @@ export {
 } from "./state-migration";
 
 export { createPlDataTableSheet } from "./createPlDataTableSheet";
-export { createPlDataTable } from "./createPlDataTable";
+export { createPlDataTable, discoverTableColumnSnaphots } from "./createPlDataTable";
 export { createPlDataTableV2 } from "./createPlDataTable/createPlDataTableV2";
+export { createPlDataTableV3 } from "./createPlDataTable/createPlDataTableV3";
 export {
   isColumnHidden,
   isColumnOptional,
-  createPlDataTableV3,
+  getOrderPriority,
+  getEffectiveVisibility,
+} from "./createPlDataTable/utils";
+
+export type {
+  ColumnsDisplayOptions,
+  ColumnOrderRule,
+  ColumnVisibilityRule,
+  ColumnMatcher,
+  ColumnsSelectorConfig,
+  createPlDataTableOptionsV3,
 } from "./createPlDataTable/createPlDataTableV3";

package/src/components/PlDataTable/labels.ts

@@ -1,32 +1,43 @@
-import type { AxisId, PColumn, PColumnIdAndSpec, PObjectId } from "@milaboratories/pl-model-common";
+import type { AxisId, PColumn, PColumnSpec, PObjectId } from "@milaboratories/pl-model-common";
 import {
   getAxisId,
   isLabelColumn,
   matchAxisId,
   PColumnName,
+  Services,
+  type RequireServices,
 } from "@milaboratories/pl-model-common";
-import type { AxisLabelProvider, ColumnProvider, PColumnDataUniversal } from "../../render";
-import { PColumnCollection } from "../../render";
+import type { PColumnDataUniversal, RenderCtxBase } from "../../render";
+import { ColumnCollectionBuilder, collectCtxColumnSnapshotProviders } from "../../columns";
+import { throwError } from "@milaboratories/helpers";
 
-/** Get all label columns from the result pool */
-export function getAllLabelColumns(
-  resultPool: AxisLabelProvider & ColumnProvider,
-): PColumn<PColumnDataUniversal>[] | undefined {
-  return new PColumnCollection()
-    .addAxisLabelProvider(resultPool)
-    .addColumnProvider(resultPool)
-    .getColumns(
-      {
-        name: PColumnName.Label,
-        axes: [{}], // exactly one axis
-      },
-      { dontWaitAllData: true, overrideLabelAnnotation: false },
-    );
+/**
+ * Get all label columns visible in the current render context
+ * (result pool + block outputs + prerun).
+ */
+export function getAllLabelColumns<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
+): PColumn<PColumnDataUniversal>[] {
+  const pframeSpec =
+    ctx.services.pframeSpec ?? throwError("PFrameSpec service is required for label discovery.");
+  const collection = new ColumnCollectionBuilder(pframeSpec)
+    .addSources(collectCtxColumnSnapshotProviders(ctx))
+    .build({ allowPartialColumnList: true });
+  try {
+    return collection
+      .findColumns({ include: { name: PColumnName.Label, axes: [] } })
+      .reduce<PColumn<PColumnDataUniversal>[]>((acc, hit) => {
+        const data = hit.data?.get();
+        return data === undefined ? acc : [...acc, { id: hit.id, spec: hit.spec, data }];
+      }, []);
+  } finally {
+    collection.dispose();
+  }
 }
 
 /** Get label columns matching the provided columns from the result pool */
 export function getMatchingLabelColumns(
-  columns: PColumnIdAndSpec[],
+  columns: { spec: PColumnSpec }[],
   allLabelColumns: PColumn<PColumnDataUniversal>[],
 ): PColumn<PColumnDataUniversal>[] {
   // split input columns into label and value columns

package/src/components/PlDataTable/state-migration.ts

@@ -188,7 +188,9 @@ function migrateV4toV5(
       currentCache && oldSourceId
         ? {
             sourceId: oldSourceId,
-            hiddenColIds: state.pTableParams.hiddenColIds,
+            hiddenColIds:
+              state.pTableParams.hiddenColIds?.map((id) => ({ type: "column" as const, id })) ??
+              null,
             filters: distillFilterSpec(currentCache.filtersState),
             sorting: state.pTableParams.sorting,
           }

package/src/components/PlDataTable/typesV5.ts

@@ -3,7 +3,6 @@ import type {
   AxisSpec,
   CanonicalizedJson,
   ListOptionBase,
-  PObjectId,
   PTableColumnSpec,
   PTableSorting,
   PColumnIdAndSpec,
@@ -63,9 +62,10 @@ export type PlDataTableSheetState = {
 };
 
 /** Tree-based filter state compatible with PlAdvancedFilter's RootFilter */
-export type PlDataTableFilters = RootFilterSpec<FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>>;
+export type PlDataTableFilterSpecLeaf = FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>;
+export type PlDataTableFilters = RootFilterSpec<PlDataTableFilterSpecLeaf>;
 export type PlDataTableFiltersWithMeta = RootFilterSpec<
-  FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>,
+  PlDataTableFilterSpecLeaf,
   { id: number; isExpanded?: boolean; source?: "table-filter" | "table-search" }
 >;
 
@@ -91,7 +91,7 @@ export type PTableParamsV2 =
     }
   | {
       sourceId: string;
-      hiddenColIds: null | PObjectId[];
+      hiddenColIds: null | PTableColumnId[];
       filters: null | PlDataTableFilters;
       sorting: PTableSorting[];
     };