@platforma-sdk/model 1.74.0 → 1.75.0

package/src/components/PlDataTable/typesV6.ts

@@ -0,0 +1,152 @@
+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 PlTableColumnIdJson = CanonicalizedJson<PTableColumnSpec>;
+
+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: 6;
+  /** 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;
+
+  /**
+   * 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";
+};

package/src/components/PlDatasetSelector/enrichment_discovery.ts

@@ -69,10 +69,10 @@ export function findEnrichmentColumns(
   });
   const predicate = options?.predicate;
   return variants.filter((v) => {
-    if (v.path.length === 0) return false;
+    if ((v.path?.length ?? 0) === 0) return false;
     if (predicate !== undefined && !predicate(v.column.spec)) return false;
     if (!isGloballyAddressable(v.column.id)) return false;
-    if (v.path.some((p) => !isGloballyAddressable(p.linker.id))) return false;
+    if (v.path?.some((p) => !isGloballyAddressable(p.linker.id))) return false;
     return true;
   });
 }
@@ -90,20 +90,20 @@ export function enrichmentVariantsToRefs(
 
   const entries: Entry[] = variants.map((variant) => ({
     spec: variant.column.spec,
-    linkerPath: variant.path.map((p) => ({ spec: p.linker.spec })),
+    linkerPath: variant.path?.map((p) => ({ spec: p.linker.spec })),
     qualifications: variant.qualifications,
   }));
   const labels = deriveDistinctLabels(entries, labelOptions);
 
   return variants.map((variant, i): LabeledEnrichmentRef => {
-    const path: EnrichmentStep[] = variant.path.map((step) => ({
+    const path: undefined | EnrichmentStep[] = variant.path?.map((step) => ({
       type: "linker",
       linker: step.linker.id,
     }));
     return {
       ref: createEnrichmentRef(variant.column.id, {
         path,
-        qualifications: variant.qualifications.forHit,
+        qualifications: variant.qualifications?.forHit,
       }),
       label: labels[i],
     };

package/src/labels/derive_distinct_labels.ts

@@ -289,7 +289,7 @@ function enrichRecord(value: Entry, index: number, options: DeriveLabelsOptions)
     }
   }
 
-  if (qualifications !== undefined) {
+  if (qualifications !== undefined && qualifications.forQueries !== undefined) {
     for (const [anchorId, qs] of Object.entries(qualifications.forQueries)) {
       if (qs.length === 0) continue;
       const anchorText = isFunction(formatters?.anchorQualification)
@@ -302,7 +302,7 @@ function enrichRecord(value: Entry, index: number, options: DeriveLabelsOptions)
         importance: -11,
       });
     }
-    if (qualifications.forHit.length > 0) {
+    if (qualifications.forHit !== undefined && qualifications.forHit.length > 0) {
       const hitText = isFunction(formatters?.hitQualification)
         ? formatters.hitQualification(qualifications.forHit, spec, index)
         : `[${formatQualifications(qualifications.forHit)}]`;

package/src/labels/derive_distinct_tooltips.ts

@@ -74,6 +74,7 @@ function formatOriginPath(entry: TooltipEntry): undefined | string {
 
 function formatAnchors(q: undefined | MatchQualifications): undefined | string {
   if (isNil(q)) return undefined;
+  if (isNil(q.forQueries)) return undefined;
   const ids = Object.keys(q.forQueries);
   if (ids.length === 0) return undefined;
 
@@ -90,7 +91,7 @@ function formatAnchors(q: undefined | MatchQualifications): undefined | string {
 }
 
 function formatHit(q: undefined | MatchQualifications): undefined | string {
-  if (isNil(q) || q.forHit.length === 0) return undefined;
+  if (isNil(q) || isNil(q.forHit) || q.forHit.length === 0) return undefined;
   const rendered = formatAxisQualifications(q.forHit);
   if (rendered === undefined) return undefined;
   return ["Hit column qualifications", `${BULLET_1}${rendered}`].join("\n");