@platforma-sdk/model 1.53.14 → 1.54.7

package/src/annotations/converter.ts

@@ -1,49 +1,21 @@
 import { when } from "@milaboratories/ptabler-expression-js";
-import type { FilterSpec } from "../filters";
-import { convertFilterUiToExpressionImpl } from "../filters/converter";
+import { convertFilterUiToExpressionImpl } from "../filters/converters/filterUiToExpressionImpl";
 import type { ExpressionSpec, FilterSpecUi } from "./types";
-
-function filterPredicate(item: FilterSpec): boolean {
-  // No need to convert empty steps
-  if (item.type == null) {
-    return false;
-  }
-
-  if (item.type === "or") {
-    return item.filters.length > 0;
-  }
-
-  if (item.type === "and") {
-    return item.filters.length > 0;
-  }
-
-  if (item.type === "not") {
-    return filterPredicate(item.filter);
-  }
-
-  // Filter out any item that has undefined values in required fields
-  return !Object.values(item).some((v) => v === undefined);
-}
-
-function filterEmptyPeaces(item: FilterSpec): FilterSpec {
-  if (item.type === "or" || item.type === "and") {
-    const filtered = item.filters.map(filterEmptyPeaces).filter(filterPredicate);
-    return {
-      ...item,
-      filters: filtered,
-    };
-  }
-
-  return item;
-}
+import { filterEmptyPieces } from "../filters/converters/filterEmpty";
 
 export function convertFilterSpecsToExpressionSpecs(
   annotationsUI: FilterSpecUi[],
 ): ExpressionSpec[] {
-  const validAnnotationsUI = annotationsUI.map((step) => ({
-    label: step.label,
-    filter: filterEmptyPeaces(step.filter),
-  }));
+  const validAnnotationsUI = annotationsUI
+    .map((step) => ({
+      label: step.label,
+      filter: filterEmptyPieces(step.filter),
+    }))
+    .filter(
+      (step): step is { label: string; filter: NonNullable<typeof step.filter> } =>
+        step.filter !== null,
+    );
+
   return validAnnotationsUI.map(
     (step): ExpressionSpec => ({
       type: "alias",

package/src/block_model.ts

@@ -70,6 +70,7 @@ export class BlockModelV3<
     supportsLazyState: true,
     requiresUIAPIVersion: 3,
     requiresModelAPIVersion: 2,
+    requiresCreatePTableV2: true,
   };
 
   /**

package/src/builder.ts

@@ -70,6 +70,7 @@ export class BlockModel<
       supportsLazyState: true,
       requiresUIAPIVersion: 1,
       requiresModelAPIVersion: 1,
+      requiresCreatePTableV2: true,
     };
   }
 

package/src/components/PlDataTable/index.ts

@@ -0,0 +1,22 @@
+// 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,
+  PlDataTableSheetState,
+  PlDataTableStateV2CacheEntry,
+  PTableParamsV2,
+  PlDataTableStateV2Normalized,
+  PlDataTableModel,
+} from "./v5";
+
+export type { PlDataTableStateV2 } from "./state-migration";
+export {
+  upgradePlDataTableStateV2,
+  createDefaultPTableParams,
+  createPlDataTableStateV2,
+} from "./state-migration";
+
+export { isColumnHidden, isColumnOptional, createPlDataTableV2 } from "./table";

package/src/components/PlDataTable/labels.ts

@@ -0,0 +1,101 @@
+import type { AxisId, PColumn, PColumnIdAndSpec, PObjectId } from "@milaboratories/pl-model-common";
+import {
+  getAxisId,
+  isLabelColumn,
+  matchAxisId,
+  PColumnName,
+} from "@milaboratories/pl-model-common";
+import type { AxisLabelProvider, ColumnProvider, PColumnDataUniversal } from "../../render";
+import { PColumnCollection } from "../../render";
+
+/** 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 label columns matching the provided columns from the result pool */
+export function getMatchingLabelColumns(
+  columns: PColumnIdAndSpec[],
+  allLabelColumns: PColumn<PColumnDataUniversal>[],
+): PColumn<PColumnDataUniversal>[] {
+  // split input columns into label and value columns
+  const inputLabelColumns: typeof columns = [];
+  const inputValueColumns: typeof columns = [];
+  for (const column of columns) {
+    if (isLabelColumn(column.spec)) {
+      inputLabelColumns.push(column);
+    } else {
+      inputValueColumns.push(column);
+    }
+  }
+
+  // collect distinct axes of value columns
+  const unlabeledAxes: AxisId[] = [];
+  for (const column of inputValueColumns) {
+    for (const axis of column.spec.axesSpec) {
+      const axisId = getAxisId(axis);
+      if (!unlabeledAxes.some((id) => matchAxisId(id, axisId))) {
+        unlabeledAxes.push(axisId);
+      }
+    }
+  }
+
+  // remove axes matched by input label columns
+  for (const labelColumn of inputLabelColumns) {
+    const labelAxisId = getAxisId(labelColumn.spec.axesSpec[0]);
+    const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+    if (labelMatch !== -1) {
+      unlabeledAxes.splice(labelMatch, 1);
+    }
+  }
+
+  // warning: changing this id will break backward compatibility
+  const colId = (id: PObjectId, domain?: Record<string, string>): PObjectId => {
+    let wid = id.toString();
+    if (domain) {
+      for (const k in domain) {
+        wid += k;
+        wid += domain[k];
+      }
+    }
+    return wid as PObjectId;
+  };
+
+  // search label columns for unmatched axes
+  const labelColumns: typeof allLabelColumns = [];
+  for (const labelColumn of allLabelColumns) {
+    const labelAxis = labelColumn.spec.axesSpec[0];
+    const labelAxisId = getAxisId(labelAxis);
+    const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+    if (labelMatch !== -1) {
+      const axisId = unlabeledAxes[labelMatch];
+      const dataDomainLen = Object.keys(axisId.domain ?? {}).length;
+      const labelDomainLen = Object.keys(labelAxis.domain ?? {}).length;
+      if (dataDomainLen > labelDomainLen) {
+        labelColumns.push({
+          id: colId(labelColumn.id, axisId.domain),
+          spec: {
+            ...labelColumn.spec,
+            axesSpec: [{ ...axisId, annotations: labelAxis.annotations }],
+          },
+          data: labelColumn.data,
+        });
+      } else {
+        labelColumns.push(labelColumn);
+      }
+      unlabeledAxes.splice(labelMatch, 1);
+    }
+  }
+  return labelColumns;
+}

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

@@ -0,0 +1,285 @@
+import type {
+  AxisId,
+  CanonicalizedJson,
+  PObjectId,
+  PTableColumnId,
+  PTableColumnSpec,
+  PTableRecordFilter,
+  PTableSorting,
+} from "@milaboratories/pl-model-common";
+import { canonicalizeJson } from "@milaboratories/pl-model-common";
+import { distillFilter } from "../../filters";
+import type { PlDataTableFilterState, PlTableFilter } from "./v4";
+import type {
+  PlDataTableAdvancedFilter,
+  PlDataTableGridStateCore,
+  PlDataTableSheetState,
+  PlDataTableStateV2CacheEntry,
+  PlDataTableStateV2Normalized,
+  PTableParamsV2,
+} from "./v5";
+
+/**
+ * PlDataTableV2 persisted state
+ */
+export type PlDataTableStateV2 =
+  // Old versions of the state
+  | {
+      // no version
+      gridState: {
+        columnOrder?: {
+          orderedColIds: CanonicalizedJson<PTableColumnSpec>[];
+        };
+        sort?: {
+          sortModel: {
+            colId: CanonicalizedJson<PTableColumnSpec>;
+            sort: "asc" | "desc";
+          }[];
+        };
+        columnVisibility?: {
+          hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];
+        };
+        sourceId?: string;
+        sheets?: Record<CanonicalizedJson<AxisId>, string | number>;
+      };
+      pTableParams?: {
+        sorting?: PTableSorting[];
+        filters?: PTableRecordFilter[];
+      };
+    }
+  | {
+      version: 2;
+      stateCache: {
+        sourceId: string;
+        gridState: {
+          columnOrder?: {
+            orderedColIds: CanonicalizedJson<PTableColumnSpec>[];
+          };
+          sort?: {
+            sortModel: {
+              colId: CanonicalizedJson<PTableColumnSpec>;
+              sort: "asc" | "desc";
+            }[];
+          };
+          columnVisibility?: {
+            hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];
+          };
+        };
+        sheetsState: PlDataTableSheetState[];
+      }[];
+      pTableParams: {
+        hiddenColIds: PObjectId[] | null;
+        filters: PTableRecordFilter[];
+        sorting: PTableSorting[];
+      };
+    }
+  | {
+      version: 3;
+      stateCache: {
+        sourceId: string;
+        gridState: {
+          columnOrder?: {
+            orderedColIds: CanonicalizedJson<PTableColumnSpec>[];
+          };
+          sort?: {
+            sortModel: {
+              colId: CanonicalizedJson<PTableColumnSpec>;
+              sort: "asc" | "desc";
+            }[];
+          };
+          columnVisibility?: {
+            hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];
+          };
+        };
+        sheetsState: PlDataTableSheetState[];
+        filtersState: PlDataTableFilterState[];
+      }[];
+      pTableParams: PTableParamsV2;
+    }
+  | {
+      version: 4;
+      stateCache: {
+        sourceId: string;
+        gridState: PlDataTableGridStateCore;
+        sheetsState: PlDataTableSheetState[];
+        filtersState: PlDataTableFilterState[];
+      }[];
+      /** Old format; only fields used in migration are typed */
+      pTableParams: {
+        sourceId: string | null;
+        hiddenColIds: PObjectId[] | null;
+        sorting: PTableSorting[];
+      };
+    }
+  // Normalized state
+  | PlDataTableStateV2Normalized;
+
+/** Upgrade PlDataTableStateV2 to the latest version */
+export function upgradePlDataTableStateV2(
+  state: PlDataTableStateV2 | undefined,
+): PlDataTableStateV2Normalized {
+  // Block just added, had no state, model started earlier than the UI
+  if (!state) {
+    return createPlDataTableStateV2();
+  }
+  // v1 -> v2
+  if (!("version" in state)) {
+    // Non upgradeable as sourceId calculation algorithm has changed, resetting state to default
+    state = createPlDataTableStateV2();
+  }
+  // v2 -> v3
+  if (state.version === 2) {
+    state = {
+      version: 3,
+      stateCache: state.stateCache.map((entry) => ({
+        ...entry,
+        filtersState: [],
+      })),
+      pTableParams: createDefaultPTableParams(),
+    };
+  }
+  // v3 -> v4
+  if (state.version === 3) {
+    // 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
+  if (state.version === 4) {
+    state = migrateV4toV5(state);
+  }
+  return state;
+}
+
+/** Migrate v4 state to v5: convert per-column filters to tree-based format */
+function migrateV4toV5(
+  state: Extract<PlDataTableStateV2, { version: 4 }>,
+): PlDataTableStateV2Normalized {
+  let idCounter = 0;
+  const nextId = () => ++idCounter;
+
+  const migratedCache: PlDataTableStateV2CacheEntry[] = state.stateCache.map((entry) => {
+    const leaves: PlDataTableAdvancedFilter[] = [];
+    for (const f of entry.filtersState) {
+      if (f.filter !== null && !f.filter.disabled) {
+        const column = canonicalizeJson<PTableColumnId>(f.id);
+        leaves.push(migrateTableFilter(column, f.filter.value, nextId));
+      }
+    }
+    const filtersState: PlDataTableAdvancedFilter | null =
+      leaves.length > 0 ? { id: nextId(), type: "and", filters: leaves } : null;
+
+    return {
+      sourceId: entry.sourceId,
+      gridState: entry.gridState,
+      sheetsState: entry.sheetsState,
+      filtersState,
+    };
+  });
+
+  const oldSourceId = state.pTableParams.sourceId;
+  const currentCache = oldSourceId
+    ? migratedCache.find((e) => e.sourceId === oldSourceId)
+    : undefined;
+
+  return {
+    version: 5,
+    stateCache: migratedCache,
+    pTableParams:
+      currentCache && oldSourceId
+        ? {
+            sourceId: oldSourceId,
+            hiddenColIds: state.pTableParams.hiddenColIds,
+            filters: distillFilter(currentCache.filtersState),
+            sorting: state.pTableParams.sorting,
+          }
+        : createDefaultPTableParams(),
+  };
+}
+
+/** Migrate a single per-column PlTableFilter to a tree-based FilterSpec node */
+function migrateTableFilter(
+  column: string,
+  filter: PlTableFilter,
+  nextId: () => number,
+): PlDataTableAdvancedFilter {
+  const id = nextId();
+  switch (filter.type) {
+    case "isNA":
+      return { id, type: "isNA", column };
+    case "isNotNA":
+      return { id, type: "isNotNA", column };
+    case "number_equals":
+      return { id, type: "equal", column, x: filter.reference };
+    case "number_notEquals":
+      return { id, type: "notEqual", column, x: filter.reference };
+    case "number_greaterThan":
+      return { id, type: "greaterThan", column, x: filter.reference };
+    case "number_greaterThanOrEqualTo":
+      return { id, type: "greaterThanOrEqual", column, x: filter.reference };
+    case "number_lessThan":
+      return { id, type: "lessThan", column, x: filter.reference };
+    case "number_lessThanOrEqualTo":
+      return { id, type: "lessThanOrEqual", column, x: filter.reference };
+    case "number_between":
+      return {
+        id,
+        type: "and",
+        filters: [
+          filter.includeLowerBound
+            ? { id: nextId(), type: "greaterThanOrEqual" as const, column, x: filter.lowerBound }
+            : { id: nextId(), type: "greaterThan" as const, column, x: filter.lowerBound },
+          filter.includeUpperBound
+            ? { id: nextId(), type: "lessThanOrEqual" as const, column, x: filter.upperBound }
+            : { id: nextId(), type: "lessThan" as const, column, x: filter.upperBound },
+        ],
+      };
+    case "string_equals":
+      return { id, type: "patternEquals", column, value: filter.reference };
+    case "string_notEquals":
+      return { id, type: "patternNotEquals", column, value: filter.reference };
+    case "string_contains":
+      return { id, type: "patternContainSubsequence", column, value: filter.reference };
+    case "string_doesNotContain":
+      return { id, type: "patternNotContainSubsequence", column, value: filter.reference };
+    case "string_matches":
+      return { id, type: "patternMatchesRegularExpression", column, value: filter.reference };
+    case "string_doesNotMatch":
+      return {
+        id,
+        type: "not",
+        filter: {
+          id: nextId(),
+          type: "patternMatchesRegularExpression",
+          column,
+          value: filter.reference,
+        },
+      };
+    case "string_containsFuzzyMatch":
+      return {
+        id,
+        type: "patternFuzzyContainSubsequence",
+        column,
+        value: filter.reference,
+        maxEdits: filter.maxEdits,
+        substitutionsOnly: filter.substitutionsOnly,
+        ...(filter.wildcard !== undefined ? { wildcard: filter.wildcard } : {}),
+      };
+  }
+}
+
+export function createDefaultPTableParams(): PTableParamsV2 {
+  return {
+    sourceId: null,
+    hiddenColIds: null,
+    filters: null,
+    sorting: [],
+  };
+}
+
+export function createPlDataTableStateV2(): PlDataTableStateV2Normalized {
+  return {
+    version: 5,
+    stateCache: [],
+    pTableParams: createDefaultPTableParams(),
+  };
+}