@platforma-sdk/model 1.53.15 → 1.54.8

package/src/components/PlDataTable/v4.ts

@@ -0,0 +1,193 @@
+import type { PTableColumnId } from "@milaboratories/pl-model-common";
+
+export type PlDataTableFilterState = {
+  id: PTableColumnId;
+  alphabetic: boolean;
+  filter: null | {
+    value: PlTableFilter;
+    disabled: boolean;
+  };
+};
+
+/** PlTableFilters filter entry */
+export type PlTableFilterIsNotNA = {
+  /** Predicate type */
+  type: "isNotNA";
+};
+
+/** PlTableFilters filter entry */
+export type PlTableFilterIsNA = {
+  /** Predicate type */
+  type: "isNA";
+};
+
+/** PlTableFilters filter entries applicable to both string and number values */
+export type PlTableFilterCommon = PlTableFilterIsNotNA | PlTableFilterIsNA;
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberEquals = {
+  /** Predicate type */
+  type: "number_equals";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberNotEquals = {
+  /** Predicate type */
+  type: "number_notEquals";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberGreaterThan = {
+  /** Predicate type */
+  type: "number_greaterThan";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberGreaterThanOrEqualTo = {
+  /** Predicate type */
+  type: "number_greaterThanOrEqualTo";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberLessThan = {
+  /** Predicate type */
+  type: "number_lessThan";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberLessThanOrEqualTo = {
+  /** Predicate type */
+  type: "number_lessThanOrEqualTo";
+  /** Reference value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberBetween = {
+  /** Predicate type */
+  type: "number_between";
+  /** Reference value for the lower bound */
+  lowerBound: number;
+  /** Defines whether values equal to lower bound reference value should be matched */
+  includeLowerBound: boolean;
+  /** Reference value for the upper bound */
+  upperBound: number;
+  /** Defines whether values equal to upper bound reference value should be matched */
+  includeUpperBound: boolean;
+};
+
+/** All PlTableFilters numeric filter entries */
+export type PlTableFilterNumber =
+  | PlTableFilterCommon
+  | PlTableFilterNumberEquals
+  | PlTableFilterNumberNotEquals
+  | PlTableFilterNumberGreaterThan
+  | PlTableFilterNumberGreaterThanOrEqualTo
+  | PlTableFilterNumberLessThan
+  | PlTableFilterNumberLessThanOrEqualTo
+  | PlTableFilterNumberBetween;
+/** All types of PlTableFilters numeric filter entries */
+export type PlTableFilterNumberType = PlTableFilterNumber["type"];
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringEquals = {
+  /** Predicate type */
+  type: "string_equals";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringNotEquals = {
+  /** Predicate type */
+  type: "string_notEquals";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringContains = {
+  /** Predicate type */
+  type: "string_contains";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringDoesNotContain = {
+  /** Predicate type */
+  type: "string_doesNotContain";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringMatches = {
+  /** Predicate type */
+  type: "string_matches";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringDoesNotMatch = {
+  /** Predicate type */
+  type: "string_doesNotMatch";
+  /** Reference value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringContainsFuzzyMatch = {
+  /** Predicate type */
+  type: "string_containsFuzzyMatch";
+  /** Reference value */
+  reference: string;
+  /**
+   * Maximum acceptable edit distance between reference value and matched substring
+   * @see https://en.wikipedia.org/wiki/Edit_distance
+   */
+  maxEdits: number;
+  /**
+   * When {@link substitutionsOnly} is set to false
+   * Levenshtein distance is used as edit distance (substitutions and indels)
+   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
+   * When {@link substitutionsOnly} is set to true
+   * Hamming distance is used as edit distance (substitutions only)
+   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   */
+  substitutionsOnly: boolean;
+  /**
+   * Single character in {@link reference} that will labelColumn any
+   * single character in searched text.
+   */
+  wildcard?: string;
+};
+
+/** All PlTableFilters string filter entries */
+export type PlTableFilterString =
+  | PlTableFilterCommon
+  | PlTableFilterStringEquals
+  | PlTableFilterStringNotEquals
+  | PlTableFilterStringContains
+  | PlTableFilterStringDoesNotContain
+  | PlTableFilterStringMatches
+  | PlTableFilterStringDoesNotMatch
+  | PlTableFilterStringContainsFuzzyMatch;
+/** All types of PlTableFilters string filter entries */
+export type PlTableFilterStringType = PlTableFilterString["type"];
+
+/** All PlTableFilters filter entries */
+export type PlTableFilter = PlTableFilterNumber | PlTableFilterString;
+/** All types of PlTableFilters filter entries */
+export type PlTableFilterType = PlTableFilter["type"];

package/src/components/PlDataTable/v5.ts

@@ -0,0 +1,140 @@
+import type {
+  AxisId,
+  AxisSpec,
+  CanonicalizedJson,
+  ListOptionBase,
+  PObjectId,
+  PTableColumnSpec,
+  PTableRecordFilter,
+  PTableSorting,
+  PColumnIdAndSpec,
+  PTableHandle,
+} from "@milaboratories/pl-model-common";
+import type { FilterSpec, FilterSpecLeaf } from "../../filters";
+
+export type PlTableColumnId = {
+  /** Original column spec */
+  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 PlDataTableFilters = FilterSpec<FilterSpecLeaf<string>>;
+export type PlDataTableFiltersWithMeta = FilterSpec<
+  FilterSpecLeaf<string>,
+  { id: number; isExpanded?: boolean }
+>;
+
+export type PlDataTableStateV2CacheEntry = {
+  /** DataSource identifier for state management */
+  sourceId: string;
+  /** Internal ag-grid state */
+  gridState: PlDataTableGridStateCore;
+  /** Sheets state */
+  sheetsState: PlDataTableSheetState[];
+  /** Filters state (tree-based, compatible with PlAdvancedFilter) */
+  filtersState: null | PlDataTableFiltersWithMeta;
+};
+
+export type PTableParamsV2 =
+  | {
+      sourceId: null;
+      hiddenColIds: null;
+      filters: null;
+      sorting: [];
+    }
+  | {
+      sourceId: string;
+      hiddenColIds: null | PObjectId[];
+      filters: null | PlDataTableFilters;
+      sorting: PTableSorting[];
+    };
+
+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: string | null;
+  /** p-table including all columns, used to show the full specification of the table */
+  fullTableHandle: PTableHandle;
+  /** p-table including only visible columns, used to get the data */
+  visibleTableHandle: PTableHandle;
+};
+
+export type CreatePlDataTableOps = {
+  /** Filters for columns and non-partitioned axes */
+  filters?: PTableRecordFilter[];
+
+  /** 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";
+};