@platforma-sdk/model 1.74.0 → 1.75.0

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

@@ -17,7 +17,7 @@ import { canonicalizeJson, getAxisId, parseJson, uniqueBy } from "@milaboratorie
 import { collectFilterSpecColumns, traverseFilterSpec } from "../../../filters/traverse";
 import type { RenderCtxBase, PColumnDataUniversal } from "../../../render";
 import { isEmpty } from "es-toolkit/compat";
-import type { PlDataTableFilters, PlDataTableFilterSpecLeaf, PlDataTableModel } from "../typesV5";
+import type { PlDataTableFilters, PlDataTableFilterSpecLeaf, PlDataTableModel } from "../typesV6";
 import { upgradePlDataTableStateV2 } from "../state-migration";
 import type { PlDataTableStateV2 } from "../state-migration";
 import type { ColumnSelector, ColumnSnapshot, ColumnVariant, MatchingMode } from "../../../columns";
@@ -36,8 +36,12 @@ import {
 } from "./utils";
 import type { PrimaryEntry, SecondaryGroup } from "./createPTableDefV3";
 import { createPTableDefV3 } from "./createPTableDefV3";
-import { discoverTableColumnSnaphots, type DiscoverTableColumnOptions } from "./discoverColumns";
-import { isNil, isPlainObject, throwError, type Nil } from "@milaboratories/helpers";
+import {
+  discoverLabelColumnVariants,
+  discoverTableColumnSnaphots,
+  type DiscoverTableColumnOptions,
+} from "./discoverColumns";
+import { getField, isNil, isPlainObject, throwError, type Nil } from "@milaboratories/helpers";
 import { flow } from "es-toolkit";
 
 export type createPlDataTableOptionsV3 = {
@@ -90,7 +94,12 @@ export function createPlDataTableV3<A, U>(
 
   const discovered = isPlainObject(options.columns)
     ? discoverTableColumnSnaphots(ctx, options.columns)
-    : options.columns;
+    : isNil(options.columns)
+      ? options.columns
+      : uniqueBy(
+          [...options.columns, ...discoverLabelColumnVariants(ctx, options.columns)],
+          (c) => c.column.id,
+        );
   if (isNil(discovered) || discovered.length === 0) return undefined;
 
   const splited = splitDiscoveredColumns(discovered);
@@ -111,7 +120,7 @@ export function createPlDataTableV3<A, U>(
   const derivedTooltips = deriveAllTooltips({
     columns: discovered.map((dc) => ({
       id: dc.column.id,
-      originalId: dc.originalId,
+      originalId: getField(dc, "originalId"),
       spec: dc.column.spec,
       linkerPath: dc.path,
       qualifications: dc.qualifications,
@@ -133,7 +142,7 @@ export function createPlDataTableV3<A, U>(
 
   const columnIsAvailable = createColumnValidationById([
     ...annotated.direct.map((v) => v.column),
-    ...annotated.linked.flatMap((lc) => [...lc.path.map((s) => s.linker), lc.column]),
+    ...annotated.linked.flatMap((lc) => [...(lc.path ?? []).map((s) => s.linker), lc.column]),
   ]);
 
   const remapedDefaultFilters = remapFilterColumnIds(options.filters, discovered);
@@ -204,8 +213,10 @@ export function createPlDataTableV3<A, U>(
   } satisfies PlDataTableModel;
 }
 
-export type TableColumnVariant = ColumnVariant<DiscoveredPColumnId> & {
-  readonly originalId: PObjectId;
+export type TableColumnVariant = (
+  | ColumnVariant<PObjectId>
+  | (ColumnVariant<DiscoveredPColumnId> & { readonly originalId: PObjectId })
+) & {
   readonly isPrimary?: boolean;
 };
 
@@ -226,15 +237,15 @@ type VisibleColumns = {
 
 /** Split discovered columns into direct (no linker path) and linked (with linker path). */
 function splitDiscoveredColumns(columns: TableColumnVariant[]): SplitDiscoveredColumns {
-  const direct = columns.filter((dc) => dc.path.length === 0);
-  const linked = columns.filter((dc) => dc.path.length > 0);
+  const direct = columns.filter((dc) => (dc.path?.length ?? 0) === 0);
+  const linked = columns.filter((dc) => (dc.path?.length ?? 0) > 0);
   return { direct, linked };
 }
 
 /** All linker snapshots across the given linked columns, deduped by id. */
 function collectLinkerSnapshots(linked: TableColumnVariant[]): ColumnSnapshot<PObjectId>[] {
   return uniqueBy(
-    linked.flatMap((lc) => lc.path.map((s) => s.linker)),
+    linked.flatMap((lc) => (lc.path ?? []).map((s) => s.linker)),
     (c) => c.id,
   );
 }
@@ -299,9 +310,13 @@ function annotateColumnGroups(params: {
 }
 
 /** Lift a snapshot-array transform so it runs on the inner `column` of each variant. */
-function liftToVariantColumns<V extends { readonly column: ColumnSnapshot<DiscoveredPColumnId> }>(
+function liftToVariantColumns<
+  V extends { readonly column: ColumnSnapshot<PObjectId | DiscoveredPColumnId> },
+>(
   variants: V[],
-  fn: (cols: ColumnSnapshot<DiscoveredPColumnId>[]) => ColumnSnapshot<DiscoveredPColumnId>[],
+  fn: (
+    cols: ColumnSnapshot<PObjectId | DiscoveredPColumnId>[],
+  ) => ColumnSnapshot<PObjectId | DiscoveredPColumnId>[],
 ): V[] {
   const cols = fn(variants.map((v) => v.column));
   if (cols.length !== variants.length)
@@ -315,7 +330,7 @@ function annotateLinkerPath(
   derivedLabels: Record<string, string>,
   path: TableColumnVariant["path"],
 ): TableColumnVariant["path"] {
-  if (path.length === 0) return path;
+  if (isNil(path) || path.length === 0) return path;
   const annotatedLinkers = withHidenAxesAnnotations(
     withLabelAnnotations(
       derivedLabels,
@@ -410,8 +425,8 @@ function buildSecondaryGroups(
   return [
     ...direct.map(
       (c): SecondaryGroup<undefined | PColumnDataUniversal> => ({
-        entries: [{ column: resolveSnapshot(c.column), qualifications: c.qualifications.forHit }],
-        primaryQualifications: c.qualifications.forQueries,
+        entries: [{ column: resolveSnapshot(c.column), qualifications: c.qualifications?.forHit }],
+        primaryQualifications: c.qualifications?.forQueries,
       }),
     ),
     ...linked.map(
@@ -419,11 +434,11 @@ function buildSecondaryGroups(
         entries: [
           {
             column: resolveSnapshot(lc.column),
-            qualifications: lc.qualifications.forHit,
-            linkers: lc.path.map((s) => resolveSnapshot(s.linker)),
+            linkers: lc.path?.map((s) => resolveSnapshot(s.linker)),
+            qualifications: lc.qualifications?.forHit,
           },
         ],
-        primaryQualifications: lc.qualifications.forQueries,
+        primaryQualifications: lc.qualifications?.forQueries,
       }),
     ),
   ];
@@ -492,7 +507,7 @@ function remapSortingColumnIds(
     if (s.column.type === "axis") return [s]; // Axis references are unaffected by column ID remapping
 
     const id = s.column.id;
-    const column = columns.find((c) => (c.originalId ?? c.column.id) === id);
+    const column = columns.find((c) => (getField(c, "originalId") ?? c.column.id) === id);
     if (column === undefined) return [];
 
     return [
@@ -524,7 +539,7 @@ function remapFilterColumnIds(
 
     const originalId = parsed.id;
     const column =
-      columns.find((c) => (c.originalId ?? c.column.id) === originalId) ??
+      columns.find((c) => (getField(c, "originalId") ?? c.column.id) === originalId) ??
       throwError(`Column ID "${parsed.id}" in filters does not match any discovered column`);
 
     return canonicalizeJson<PTableColumnId>({

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

@@ -1,5 +1,5 @@
 import type { PColumnSpec, PlRef, PObjectId } from "@milaboratories/pl-model-common";
-import { createDiscoveredPColumnId, isPlRef } from "@milaboratories/pl-model-common";
+import { createDiscoveredPColumnId, isPlRef, PColumnName } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
 import type {
   ColumnSource,
@@ -42,9 +42,7 @@ export function discoverTableColumnSnaphots(
   if (collection === undefined) return undefined;
 
   try {
-    const variants = collection.findColumnVariants({
-      ...(resolvedOptions.selector ?? {}),
-    });
+    const variants = collection.findColumnVariants(resolvedOptions.selector);
     const anchors = collection.getAnchors();
     return mapToTableColumnVariants(variants, anchors);
   } finally {
@@ -52,7 +50,58 @@ export function discoverTableColumnSnaphots(
   }
 }
 
-// --- Pure helper functions ---
+/**
+ * Discover label columns matching the axes of the given value columns from
+ * ctx providers. Returns label snapshots wrapped as direct TableColumnVariants
+ * (path: [], empty qualifications, isPrimary: false).
+ */
+export function discoverLabelColumnVariants<A, U>(
+  ctx: RenderCtxBase<A, U>,
+  columns: TableColumnVariant[],
+): TableColumnVariant[] {
+  if (columns.length === 0) return [];
+  const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec"))
+    .addSources(collectCtxColumnSnapshotProviders(ctx))
+    .addSource(columns.map((c) => c.column))
+    .build({
+      allowPartialColumnList: true,
+      anchors: Object.fromEntries(
+        columns
+          .filter((col) => (col.path?.length ?? 0) === 0 && col.isPrimary)
+          .map((col, i) => [`anchor_${i}`, col.column.spec]),
+      ),
+    });
+
+  try {
+    const axes = columns.flatMap((col) => col.column.spec.axesSpec);
+    return collection
+      .findColumnVariants({
+        include: axes.map((a) => ({
+          name: { type: "exact", value: PColumnName.Label },
+          axes: [{ name: { type: "exact", value: a.name } }],
+        })),
+        maxHops: columns.reduce((acc, c) => Math.max(acc, c.path?.length ?? 0), 0),
+      })
+      .map((variant) => ({
+        ...variant,
+        column: {
+          ...variant.column,
+          id: createDiscoveredPColumnId({
+            column: variant.column.id,
+            path: variant.path?.map((p) => ({
+              type: "linker",
+              column: p.linker.id,
+            })),
+            columnQualifications: variant.qualifications?.forHit,
+            queriesQualifications: variant.qualifications?.forQueries,
+          }),
+          originalId: variant.column.id,
+        },
+      }));
+  } finally {
+    collection.dispose();
+  }
+}
 
 /** Resolve PlRef values in anchors to PColumnSpec via the result pool. */
 function resolveAnchors(
@@ -99,12 +148,12 @@ function mapToTableColumnVariants(
 
     const discoveredId = createDiscoveredPColumnId({
       column: snap.id,
-      path: variant.path.map((p) => ({
+      path: variant.path?.map((p) => ({
         type: "linker",
         column: p.linker.id,
       })),
-      columnQualifications: variant.qualifications.forHit,
-      queriesQualifications: variant.qualifications.forQueries,
+      columnQualifications: variant.qualifications?.forHit,
+      queriesQualifications: variant.qualifications?.forQueries,
     });
     return {
       column: {

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

@@ -1,5 +1,5 @@
 import type { RenderCtxBase } from "../../../render";
-import type { PlDataTableModel } from "../typesV5";
+import type { PlDataTableModel } from "../typesV6";
 import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataTableV2";
 import { createPlDataTableV3 } from "./createPlDataTableV3";
 import type { createPlDataTableOptionsV3 } from "./createPlDataTableV3";

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

@@ -114,7 +114,7 @@ describe("deriveAllLabels", () => {
       makeLabelableColumn(
         "c1",
         { name: "shared", annotations: { [Annotation.Label]: "Cluster size" } },
-        [{ linker: { id: "lk" as PObjectId, spec: linkerSpec } as never, qualifications: [] }],
+        [{ linker: { id: "lk" as PObjectId, spec: linkerSpec } as never }],
       ),
       makeLabelableColumn("c2", {
         name: "shared",

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

@@ -7,7 +7,6 @@ import {
   canonicalizeAxisId,
   DiscoveredPColumnId,
   readAnnotation,
-  readAnnotationJson,
 } from "@milaboratories/pl-model-common";
 import {
   deriveDistinctLabels,
@@ -22,6 +21,7 @@ import type { ColumnMatcher, ColumnOrderRule, ColumnVisibilityRule } from "./cre
 import type { ColumnSelector } from "../../../columns";
 import { ArrayColumnProvider, ColumnCollectionBuilder } from "../../../columns";
 import { isNil } from "es-toolkit";
+import { getField } from "@milaboratories/helpers";
 
 /** Check if column should be omitted from the table */
 export function isColumnHidden(spec: { annotations?: Annotation }): boolean {
@@ -55,7 +55,8 @@ export function getOrderPriority(
 ): undefined | number {
   const rule = orderByColId?.get(col.id);
   if (rule !== undefined) return rule.priority;
-  return readAnnotationJson(col.spec, Annotation.Table.OrderPriority);
+  const annotation = Number(readAnnotation(col.spec, Annotation.Table.OrderPriority));
+  return isNaN(annotation) ? undefined : annotation;
 }
 
 /**
@@ -276,9 +277,9 @@ export function deriveAllLabels(options: {
 
 /** Column shape required by tooltip derivation. */
 export type TooltipableColumn = {
-  readonly id: DiscoveredPColumnId;
+  readonly id: PObjectId | DiscoveredPColumnId;
   readonly spec: PColumnSpec;
-  readonly originalId: PObjectId;
+  readonly originalId?: PObjectId;
   readonly linkerPath?: MatchVariant["path"];
   readonly qualifications?: MatchQualifications;
 };
@@ -290,15 +291,15 @@ export function deriveAllTooltips(options: {
   const { columns } = options;
 
   const variantCountByOriginal = columns.reduce<Map<PObjectId, number>>((acc, c) => {
-    return acc.set(c.originalId, (acc.get(c.originalId) ?? 0) + 1);
+    return acc.set(getField(c, "originalId") ?? c.id, (acc.get(c.originalId ?? c.id) ?? 0) + 1);
   }, new Map());
 
   const { entries } = columns.reduce(
     ({ entries, variantSeen }, c) => {
-      const variantCount = variantCountByOriginal.get(c.originalId);
+      const id = getField(c, "originalId") ?? c.id;
+      const variantCount = variantCountByOriginal.get(id);
       const variantIndex =
-        (variantSeen.set(c.originalId, (variantSeen.get(c.originalId) ?? 0) + 1),
-        variantSeen.get(c.originalId));
+        (variantSeen.set(id, (variantSeen.get(id) ?? 0) + 1), variantSeen.get(id));
 
       entries.push({
         spec: c.spec,

package/src/components/PlDataTable/createPlDataTableSheet.ts

@@ -1,6 +1,6 @@
 import type { AxisSpec } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../render";
-import type { PlDataTableSheet } from "./typesV5";
+import type { PlDataTableSheet } from "./typesV6";
 
 /** Create sheet entries for PlDataTable */
 export function createPlDataTableSheet<A, U>(

package/src/components/PlDataTable/index.ts

@@ -1,7 +1,6 @@
 // If you need to export something from previous versions,
 // that mean you don't forget update deps to the latest version of the package.
 export type {
-  PlTableColumnId,
   PlTableColumnIdJson,
   PlDataTableGridStateCore,
   PlDataTableSheet,
@@ -14,7 +13,7 @@ export type {
   PlDataTableFilterMeta,
   PlDataTableFilters,
   PlDataTableFiltersWithMeta,
-} from "./typesV5";
+} from "./typesV6";
 
 export type { PlDataTableStateV2 } from "./state-migration";
 export {

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

@@ -7,7 +7,7 @@ import type {
   PTableRecordFilter,
   PTableSorting,
 } from "@milaboratories/pl-model-common";
-import { canonicalizeJson } from "@milaboratories/pl-model-common";
+import { canonicalizeJson, parseJson } from "@milaboratories/pl-model-common";
 import { distillFilterSpec } from "../../filters";
 import type { PlDataTableFilterState, PlTableFilter } from "./typesV4";
 import type {
@@ -17,7 +17,8 @@ import type {
   PlDataTableStateV2CacheEntry,
   PlDataTableStateV2Normalized,
   PTableParamsV2,
-} from "./typesV5";
+} from "./typesV6";
+import type { PlDataTableGridStateV5, PlDataTableV5ColIdJson } from "./typesV5";
 
 /**
  * PlDataTableV2 persisted state
@@ -111,6 +112,19 @@ export type PlDataTableStateV2 =
         sorting: PTableSorting[];
       };
     }
+  // v5 stored colIds as `{source, labeled}` wrappers; only the gridState shape differs.
+  | {
+      version: 5;
+      stateCache: {
+        sourceId: string;
+        gridState: PlDataTableGridStateV5;
+        sheetsState: PlDataTableSheetState[];
+        filtersState: null | PlDataTableFiltersWithMeta;
+        defaultFiltersState: null | PlDataTableFiltersWithMeta;
+        searchString?: string;
+      }[];
+      pTableParams: PTableParamsV2;
+    }
   // Normalized state
   | PlDataTableStateV2Normalized;
 
@@ -143,15 +157,64 @@ export function upgradePlDataTableStateV2(
     // Non upgradeable as column ids calculation algorithm has changed, resetting state to default
     state = createPlDataTableStateV2();
   }
-  // v4 -> v5: migrate per-column filters to tree-based format
+  // v4 -> v6: migrate per-column filters to tree-based format (skips v5).
+  // v4 gridState already used bare PTableColumnSpec colIds, so we jump
+  // straight to v6 without going through the v5 wrapper format.
   if (state.version === 4) {
-    state = migrateV4toV5(state);
+    state = migrateV4toV6(state);
+  }
+  // v5 -> v6: unwrap `{source, labeled}` colIds in gridState back to bare PTableColumnSpec.
+  if (state.version === 5) {
+    state = migrateV5toV6(state);
   }
   return state;
 }
 
-/** Migrate v4 state to v5: convert per-column filters to tree-based format */
-function migrateV4toV5(
+/** Migrate v5 to v6: unwrap `{source, labeled}` colIds in gridState. */
+function migrateV5toV6(
+  state: Extract<PlDataTableStateV2, { version: 5 }>,
+): PlDataTableStateV2Normalized {
+  // pTableParams reset: v5 stored DiscoveredPColumnId-based hiddenColIds with
+  // empty-array fields (e.g. `{column, path: [], columnQualifications: [], ...}`).
+  // v6 distills empty fields, so the same logical column serialises differently
+  // and lookups would silently miss every previously-hidden discovered column.
+  // gridState colIds are derived from PTableColumnSpec and unaffected.
+  return {
+    version: 6,
+    stateCache: state.stateCache.map((entry) => ({
+      ...entry,
+      gridState: unwrapV5GridState(entry.gridState),
+    })),
+    pTableParams: createDefaultPTableParams(),
+  };
+}
+
+/** Convert v5 wrapped colId JSON to bare PTableColumnSpec JSON, taking `.source`. */
+function unwrapV5ColId(json: PlDataTableV5ColIdJson): CanonicalizedJson<PTableColumnSpec> {
+  return canonicalizeJson(parseJson(json).source);
+}
+
+function unwrapV5GridState(gridState: PlDataTableGridStateV5): PlDataTableGridStateCore {
+  return {
+    columnOrder: gridState.columnOrder
+      ? { orderedColIds: gridState.columnOrder.orderedColIds.map(unwrapV5ColId) }
+      : undefined,
+    sort: gridState.sort
+      ? {
+          sortModel: gridState.sort.sortModel.map((s) => ({
+            colId: unwrapV5ColId(s.colId),
+            sort: s.sort,
+          })),
+        }
+      : undefined,
+    columnVisibility: gridState.columnVisibility
+      ? { hiddenColIds: gridState.columnVisibility.hiddenColIds.map(unwrapV5ColId) }
+      : undefined,
+  };
+}
+
+/** Migrate v4 state to v6: convert per-column filters to tree-based format (skips v5). */
+function migrateV4toV6(
   state: Extract<PlDataTableStateV2, { version: 4 }>,
 ): PlDataTableStateV2Normalized {
   let idCounter = 0;
@@ -183,7 +246,7 @@ function migrateV4toV5(
     : undefined;
 
   return {
-    version: 5,
+    version: 6,
     stateCache: migratedCache,
     pTableParams:
       currentCache && oldSourceId
@@ -283,7 +346,7 @@ export function createDefaultPTableParams(): PTableParamsV2 {
 
 export function createPlDataTableStateV2(): PlDataTableStateV2Normalized {
   return {
-    version: 5,
+    version: 6,
     stateCache: [],
     pTableParams: createDefaultPTableParams(),
   };

package/src/components/PlDataTable/typesV5.ts

@@ -1,159 +1,20 @@
-import type {
-  AxisId,
-  AxisSpec,
-  CanonicalizedJson,
-  ListOptionBase,
-  PTableColumnSpec,
-  PTableSorting,
-  PColumnIdAndSpec,
-  PTableHandle,
-  RootFilterSpec,
-  PTableColumnId,
-  PFrameHandle,
-} from "@milaboratories/pl-model-common";
-import type { FilterSpecLeaf } from "../../filters";
-import { Nil } from "@milaboratories/helpers";
-
-export type PlTableColumnId = {
-  /** Original column spec */
+import type { CanonicalizedJson, PTableColumnSpec } from "@milaboratories/pl-model-common";
+
+/**
+ * v5 colId wrapper. v5 stored every grid colId as `{ source, labeled }` —
+ * `source` was the original column spec, `labeled` was the spec with
+ * labeled axes substituted by their label columns. v6 dropped the wrapper
+ * and stores bare `PTableColumnSpec`. Kept here for the v5→v6 migration.
+ */
+export type PlDataTableV5ColIdWrapper = {
   source: PTableColumnSpec;
-  /** Column spec with labeled axes replaced by label columns */
   labeled: PTableColumnSpec;
 };
 
-export type PlTableColumnIdJson = CanonicalizedJson<PlTableColumnId>;
-
-export type PlDataTableGridStateCore = {
-  /** Includes column ordering */
-  columnOrder?: {
-    /** All colIds in order */
-    orderedColIds: PlTableColumnIdJson[];
-  };
-  /** Includes current sort columns and direction */
-  sort?: {
-    /** Sorted columns and directions in order */
-    sortModel: {
-      /** Column Id to apply the sort to. */
-      colId: PlTableColumnIdJson;
-      /** Sort direction */
-      sort: "asc" | "desc";
-    }[];
-  };
-  /** Includes column visibility */
-  columnVisibility?: {
-    /** All colIds which were hidden */
-    hiddenColIds: PlTableColumnIdJson[];
-  };
-};
-
-export type PlDataTableSheet = {
-  /** spec of the axis to use */
-  axis: AxisSpec;
-  /** options to show in the filter dropdown */
-  options: ListOptionBase<string | number>[];
-  /** default (selected) value */
-  defaultValue?: string | number;
-};
-
-export type PlDataTableSheetState = {
-  /** id of the axis */
-  axisId: AxisId;
-  /** selected value */
-  value: string | number;
-};
-
-/** Tree-based filter state compatible with PlAdvancedFilter's RootFilter */
-export type PlDataTableFilterMeta = {
-  id: number;
-  source?: "table-filter" | "table-search";
-  isExpanded?: boolean;
-  isSuppressed?: boolean;
-};
-export type PlDataTableFilterSpecLeaf = FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>;
-export type PlDataTableFilters = RootFilterSpec<PlDataTableFilterSpecLeaf>;
-export type PlDataTableFiltersWithMeta = RootFilterSpec<
-  PlDataTableFilterSpecLeaf,
-  PlDataTableFilterMeta
->;
-
-export type PlDataTableStateV2CacheEntry = {
-  /** DataSource identifier for state management */
-  sourceId: string;
-  /** Internal ag-grid state */
-  gridState: PlDataTableGridStateCore;
-  /** Sheets state */
-  sheetsState: PlDataTableSheetState[];
-  /** User filters state (tree-based, compatible with PlAdvancedFilter) */
-  filtersState: null | PlDataTableFiltersWithMeta;
-  /** Default filters state from model (snapshot of defaults) */
-  defaultFiltersState: null | PlDataTableFiltersWithMeta;
-  /** Fast search string */
-  searchString?: string;
-};
-
-export type PTableParamsV2 =
-  | {
-      sourceId: null;
-      hiddenColIds: null;
-      sorting: [];
-      filters: null;
-      defaultFilters: null;
-    }
-  | {
-      sourceId: string;
-      hiddenColIds: null | PTableColumnId[];
-      sorting: PTableSorting[];
-      filters: null | PlDataTableFilters;
-      defaultFilters: null | PlDataTableFilters;
-    };
-
-export type PlDataTableStateV2Normalized = {
-  /** Version for upgrades */
-  version: 5;
-  /** Internal states, LRU cache for 5 sourceId-s */
-  stateCache: PlDataTableStateV2CacheEntry[];
-  /** PTable params derived from the cache state for the current sourceId */
-  pTableParams: PTableParamsV2;
-};
-
-/** PlAgDataTable model */
-export type PlDataTableModel = {
-  /** DataSource identifier for state management */
-  sourceId: null | string;
-  /** p-table including all columns, used to show the full specification of the table */
-  fullTableHandle?: PTableHandle;
-  /** p-frame handle */
-  fullPframeHandle?: PFrameHandle;
-  /** p-table including only visible columns, used to get the data */
-  visibleTableHandle?: PTableHandle;
-  /** Default filters from model options, surfaced for UI display */
-  defaultFilters?: Nil | PlDataTableFilters;
-};
-
-export type CreatePlDataTableOps = {
-  /** Filters for columns and non-partitioned axes */
-  filters?: PlDataTableFilters;
-
-  /** Sorting to columns hidden from user */
-  sorting?: PTableSorting[];
-
-  /**
-   * Selects columns for which will be inner-joined to the table.
-   *
-   * Default behaviour: all columns are considered to be core
-   */
-  coreColumnPredicate?: (spec: PColumnIdAndSpec) => boolean;
+export type PlDataTableV5ColIdJson = CanonicalizedJson<PlDataTableV5ColIdWrapper>;
 
-  /**
-   * Determines how core columns should be joined together:
-   *   inner - so user will only see records present in all core columns
-   *   full - so user will only see records present in any of the core columns
-   *
-   * All non-core columns will be left joined to the table produced by the core
-   * columns, in other words records form the pool of non-core columns will only
-   * make their way into the final table if core table contains corresponding key.
-   *
-   * Default: 'full'
-   */
-  coreJoinType?: "inner" | "full";
+export type PlDataTableGridStateV5 = {
+  columnOrder?: { orderedColIds: PlDataTableV5ColIdJson[] };
+  sort?: { sortModel: { colId: PlDataTableV5ColIdJson; sort: "asc" | "desc" }[] };
+  columnVisibility?: { hiddenColIds: PlDataTableV5ColIdJson[] };
 };