@platforma-sdk/model 1.9.0 → 1.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/model",
-  "version": "1.9.0",
+  "version": "1.10.2",
   "description": "Platforma.bio SDK / Block Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

package/src/components/PlDataTable.ts

@@ -28,7 +28,9 @@ export type PlDataTableGridState = {
       sort: 'asc' | 'desc';
     }[];
   };
+  /** Includes column visibility */
   columnVisibility?: {
+    /** All colIds which were hidden */
     hiddenColIds: string[];
   };
 
@@ -52,11 +54,201 @@ export type PTableParams = {
 export type PlDataTableState = {
   // internal ag-grid state
   gridState: PlDataTableGridState;
-
   // mapping of gridState onto the p-table data structures
   pTableParams?: PTableParams;
 };
 
+/** 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';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberNotEquals = {
+  /** Predicate type */
+  type: 'number_notEquals';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberGreaterThen = {
+  /** Predicate type */
+  type: 'number_greaterThen';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberGreaterThenOrEqualTo = {
+  /** Predicate type */
+  type: 'number_greaterThenOrEqualTo';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberLessThen = {
+  /** Predicate type */
+  type: 'number_lessThen';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberLessThenOrEqualTo = {
+  /** Predicate type */
+  type: 'number_lessThenOrEqualTo';
+  /** Referense value */
+  reference: number;
+};
+
+/** PlTableFilters numeric filter entry */
+export type PlTableFilterNumberBetween = {
+  /** Predicate type */
+  type: 'number_between';
+  /** Referense value for the lower bound */
+  lowerBound: number;
+  /** Defines whether values equal to lower bound reference value should be matched */
+  includeLowerBound: boolean;
+  /** Referense 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
+  | PlTableFilterNumberGreaterThen
+  | PlTableFilterNumberGreaterThenOrEqualTo
+  | PlTableFilterNumberLessThen
+  | PlTableFilterNumberLessThenOrEqualTo
+  | 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';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringNotEquals = {
+  /** Predicate type */
+  type: 'string_notEquals';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringContains = {
+  /** Predicate type */
+  type: 'string_contains';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringDoesNotContain = {
+  /** Predicate type */
+  type: 'string_doesNotContain';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringMatches = {
+  /** Predicate type */
+  type: 'string_matches';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringDoesNotMatch = {
+  /** Predicate type */
+  type: 'string_doesNotMatch';
+  /** Referense value */
+  reference: string;
+};
+
+/** PlTableFilters string filter entry */
+export type PlTableFilterStringContainsFuzzyMatch = {
+  /** Predicate type */
+  type: 'string_containsFuzzyMatch';
+  /** Referense 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 match 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'];
+
+/** PlTableFilters model */
+export type PlTableFiltersModel = {
+  /** Internal PlTableFilters component state, do not change! */
+  state?: Record<string, PlTableFilter>;
+  /** Resulting filters which should be used in Join */
+  filters?: PTableRecordFilter[];
+};
+
 /**
  * Create p-table handle given ui table state
  *

package/src/render/accessor.ts

@@ -47,6 +47,7 @@ type FieldMapOps = {
 export class TreeNodeAccessor {
   constructor(public readonly handle: AccessorHandle) {}
 
+  /** Shortcut for {@link resolveInput} */
   public resolve(
     ...steps: [
       Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
@@ -54,8 +55,70 @@ export class TreeNodeAccessor {
       }
     ]
   ): TreeNodeAccessor;
+  /** Shortcut for {@link resolveInput} */
   public resolve(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
   public resolve(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Input',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  /** If field type assertion is not specified for the step, default is Output. */
+  public resolveOutput(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  /** If field type assertion is not specified for the step, default is Output. */
+  public resolveOutput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveOutput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Output',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  /** If field type assertion is not specified for the step, default is Input. */
+  public resolveInput(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  /** If field type assertion is not specified for the step, default is Input. */
+  public resolveInput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveInput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Input',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  public resolveAny(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
     return this.resolveWithCommon({}, ...steps);
   }
 

package/src/render/index.ts

@@ -1,5 +1,6 @@
 export * from './api';
 export * from './traversal_ops';
 export * from './accessor';
+export * from './util';
 export { type ExtractFutureRefType } from './future';
 export { FutureRef } from './future';

package/src/render/traversal_ops.ts

@@ -46,8 +46,11 @@ export type GetFieldStep = CommonFieldTraverseOps & {
   errorIfFieldNotSet?: true;
 
   /**
-   * Assert field type. Call will fail with exception if this assertion is not
-   * fulfilled
+   * Assert field type.
+   * Call will fail with exception if this assertion is not fulfilled.
+   * The information about expectedFieldType is also used for stability
+   * calculation and field absence error generation, so it is always a good
+   * ide to specify it.
    * */
   assertFieldType?: FieldType;
 };

package/src/render/util/index.ts

@@ -0,0 +1 @@
+export * from './resource_map'

package/src/render/util/resource_map.ts

@@ -0,0 +1,74 @@
+import { TreeNodeAccessor } from "../accessor";
+
+export const ResourceMapResourceTypeName = 'PColumnData/ResourceMap';
+export const ResourceMapResourcePartitionedTypeName = 'PColumnData/Partitioned/ResourceMap';
+
+export type PColumnKey = (string | number)[];
+
+export type PColumnResourceMapEntry<T> = {
+  key: PColumnKey;
+  value: T;
+};
+
+export type PColumnResourceMapData<T> = {
+  isComplete: boolean;
+  data: PColumnResourceMapEntry<T>[];
+};
+
+function populateResourceMapData<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  data: PColumnResourceMapEntry<T | undefined>[],
+  keyPrefix: PColumnKey = [],
+  addEntriesWithNoData: boolean
+): boolean {
+  if (acc === undefined) return false;
+  switch (acc.resourceType.name) {
+    case ResourceMapResourceTypeName: {
+      let isComplete = acc.getInputsLocked();
+      for (const keyStr of acc.listInputFields()) {
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        const key = [...keyPrefix, ...JSON.parse(keyStr)] as PColumnKey;
+        const converted = value === undefined ? undefined : resourceParser(value);
+        if (converted === undefined) isComplete = false;
+        if (converted !== undefined || addEntriesWithNoData) data.push({ key, value: converted });
+      }
+      return isComplete;
+    }
+    case ResourceMapResourcePartitionedTypeName: {
+      let isComplete = acc.getInputsLocked();
+      for (const keyStr of acc.listInputFields()) {
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        if (value === undefined) isComplete = false;
+        else {
+          const key = [...keyPrefix, ...JSON.parse(keyStr)] as PColumnKey;
+          const populateResult = populateResourceMapData(value, resourceParser, data, key, addEntriesWithNoData)
+          isComplete = isComplete && populateResult;
+        }
+      }
+      return isComplete;
+    }
+    default:
+      throw new Error(`Unknown resource type: ${acc.resourceType.name}`);
+  }
+}
+
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: false
+): PColumnResourceMapData<NonNullable<T>>;
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: true
+): PColumnResourceMapData<T | undefined>;
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: boolean = false
+): PColumnResourceMapData<T | undefined> {
+  const data: PColumnResourceMapEntry<T | undefined>[] = [];
+  const isComplete = populateResourceMapData(acc, resourceParser, data, [], addEntriesWithNoData);
+  return { isComplete, data };
+}