@platforma-sdk/ui-vue 1.45.34 → 1.45.36

package/src/components/PlAdvancedFilter/types.ts

@@ -0,0 +1,77 @@
+import type { AxisSpec, FilterSpec, FilterSpecLeaf, FilterSpecType, ListOptionBase, PColumnSpec, SUniversalPColumnId } from '@platforma-sdk/model';
+import { SUPPORTED_FILTER_TYPES } from './constants';
+import type { CanonicalizedJson } from '@platforma-sdk/model';
+import type { AxisId } from '@platforma-sdk/model';
+
+export type PlAdvancedFilterColumnId = SUniversalPColumnId | CanonicalizedJson<AxisId>;
+export type CommonFilterSpec = FilterSpec<FilterSpecLeaf<PlAdvancedFilterColumnId>, { expanded?: boolean }>;
+
+// Not supported: topN, bottomN, lessThanColumn, lessThanColumnOrEqual
+// or, and, not - in groups
+export type SupportedFilterTypes = FilterSpecType &
+  'isNA' | 'isNotNA' |
+  'patternEquals' | 'patternNotEquals' |
+  'patternContainSubsequence' | 'patternNotContainSubsequence' |
+  'patternMatchesRegularExpression' |
+  'patternFuzzyContainSubsequence' |
+  'inSet' | 'notInSet' |
+  'equal' | 'notEqual' |
+  'lessThan' | 'lessThanOrEqual' |
+  'greaterThan' | 'greaterThanOrEqual';
+
+export type FilterType = SupportedFilterTypes;
+
+export function isSupportedFilterType(type: FilterSpecType | undefined): type is SupportedFilterTypes {
+  if (!type) {
+    return false;
+  }
+  return SUPPORTED_FILTER_TYPES.has(type as SupportedFilterTypes);
+}
+
+export type Operand = 'or' | 'and';
+
+type FilterUiBase = FilterSpecLeaf<PlAdvancedFilterColumnId> & {
+  type: SupportedFilterTypes;
+  column: PlAdvancedFilterColumnId;
+};
+
+type RequireFields<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+type OptionalFields<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+type NumericalWithOptionalX = 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'equal' | 'notEqual';
+type StringWithOptionalValue = 'patternEquals' | 'patternNotEquals';
+type EditedTypes = SupportedFilterTypes & ('patternFuzzyContainSubsequence' | NumericalWithOptionalX | StringWithOptionalValue); // types from ui with some changed by optionality fields
+export type Filter = Exclude<FilterUiBase, { type: EditedTypes }> |
+  RequireFields<Extract<FilterUiBase, { type: 'patternFuzzyContainSubsequence' }>, 'maxEdits' | 'substitutionsOnly'> |
+  OptionalFields<Extract<FilterUiBase, { type: NumericalWithOptionalX }>, 'x'> |
+  OptionalFields<Extract<FilterUiBase, { type: StringWithOptionalValue }>, 'value'>
+;
+
+export type Group = {
+  id: string;
+  not: boolean;
+  filters: Filter[];
+  operand: Operand;
+  expanded: boolean;
+};
+
+export type PlAdvancedFilterUI = {
+  groups: Group[];
+  operand: Operand;
+};
+
+export type UniqueValuesList = ListOptionBase<string | number>[];
+export type OptionInfo = { error: boolean; label: string; spec: PColumnSpec | AxisSpec };
+export type FixedAxisInfo = {
+  idx: number;
+  label: string;
+};
+
+export type SourceOptionInfo = {
+  id: PlAdvancedFilterColumnId;
+  label: string;
+  error: boolean;
+  spec: PColumnSpec | AxisSpec;
+  axesToBeFixed?: FixedAxisInfo[];
+  alphabet?: 'nucleotide' | 'aminoacid' | string;
+};

package/src/components/PlAdvancedFilter/utils.ts

@@ -0,0 +1,215 @@
+import type { AnchoredPColumnId, AxisId, CanonicalizedJson, FilteredPColumnId, ValueType } from '@platforma-sdk/model';
+import { assertNever, getTypeFromPColumnOrAxisSpec, isAnchoredPColumnId, isFilteredPColumn, parseJson, type AxisSpec, type PColumnSpec, type SUniversalPColumnId } from '@platforma-sdk/model';
+import { type CommonFilterSpec, isSupportedFilterType, type Filter, type FilterType, type Group, type PlAdvancedFilterUI, type SupportedFilterTypes, type PlAdvancedFilterColumnId } from './types';
+import { DEFAULT_FILTER_TYPE, DEFAULT_FILTERS, SUPPORTED_FILTER_TYPES } from './constants';
+import { filterUiMetadata } from '@milaboratories/uikit';
+import { ref, watch, type ModelRef } from 'vue';
+import { isAxisId } from '@platforma-sdk/model';
+
+function toInnerFilter(outerFilter: CommonFilterSpec): Filter | null {
+  if (!('column' in outerFilter) || outerFilter.type === undefined || !isSupportedFilterType(outerFilter.type)) {
+    return null;
+  }
+  if (outerFilter.type === 'patternFuzzyContainSubsequence') {
+    return {
+      ...outerFilter,
+      value: outerFilter.value,
+      wildcard: outerFilter.wildcard,
+      maxEdits: outerFilter.maxEdits ?? 2,
+      substitutionsOnly: outerFilter.substitutionsOnly ?? false,
+    };
+  }
+
+  return { ...outerFilter } as Filter;
+}
+
+let groupIdCounter = 0;
+function getNewGroupId() {
+  groupIdCounter++;
+  return String(groupIdCounter);
+}
+
+function toInnerFiltersGroup(f: CommonFilterSpec): Group | null {
+  if (f.type === 'not') {
+    const group = toInnerFiltersGroup(f.filter);
+    return group
+      ? {
+          not: !group.not,
+          operand: group.operand,
+          filters: group.filters,
+          id: getNewGroupId(),
+          expanded: group.expanded,
+        }
+      : null;
+  }
+  if (f.type === 'and' || f.type === 'or') {
+    return {
+      operand: f.type,
+      not: false,
+      filters: f.filters.map((f) => toInnerFilter(f)).filter((v) => v !== null) as Filter[],
+      id: getNewGroupId(),
+      expanded: f.expanded ?? true,
+    };
+  }
+  if (SUPPORTED_FILTER_TYPES.has(f.type as SupportedFilterTypes)) {
+    const filter = toInnerFilter(f);
+    return {
+      operand: 'or',
+      not: false,
+      filters: filter ? [filter] : [],
+      id: getNewGroupId(),
+      expanded: f.expanded ?? true,
+    };
+  }
+  return null;
+}
+
+export function toInnerModel(m: CommonFilterSpec): PlAdvancedFilterUI {
+  const res: PlAdvancedFilterUI = {
+    operand: 'or',
+    groups: [],
+  };
+  if (m.type === 'not') {
+    return res; // not supported 'not' for all the groups in ui
+  }
+  if (m.type === 'and' || m.type === 'or') {
+    // group
+    res.operand = m.type;
+    res.groups = m.filters.map(toInnerFiltersGroup).filter((v) => v !== null) as Group[];
+  } else if (SUPPORTED_FILTER_TYPES.has(m.type as SupportedFilterTypes)) {
+    // single filter
+    const group = toInnerFiltersGroup(m);
+    res.groups = group ? [group] : [];
+  }
+  res.groups = res.groups.filter((gr) => gr.filters.length > 0);
+  return res;
+}
+
+function toOuterFilter(filter: Filter): CommonFilterSpec | null {
+  if (
+    filter.type === 'isNA' || filter.type === 'isNotNA'
+    || filter.type === 'inSet' || filter.type === 'notInSet'
+  ) {
+    return filter;
+  }
+  if (
+    filter.type === 'greaterThanOrEqual' || filter.type === 'lessThanOrEqual'
+    || filter.type === 'greaterThan' || filter.type === 'lessThan'
+    || filter.type === 'equal' || filter.type === 'notEqual'
+  ) {
+    return filter.x !== undefined ? { ...filter, x: filter.x } : null;
+  }
+  if (
+    filter.type === 'patternEquals' || filter.type === 'patternNotEquals'
+    || filter.type === 'patternContainSubsequence' || filter.type === 'patternNotContainSubsequence'
+    || filter.type === 'patternMatchesRegularExpression'
+    || filter.type === 'patternFuzzyContainSubsequence'
+  ) {
+    return filter.value !== undefined ? { ...filter, value: filter.value } : null;
+  }
+  assertNever(filter.type);
+}
+
+function toOuterFilterGroup(m: Group): CommonFilterSpec {
+  const res: CommonFilterSpec = {
+    type: m.operand,
+    expanded: m.expanded,
+    filters: m.filters.map(toOuterFilter).filter((v): v is CommonFilterSpec => v !== null),
+  };
+  if (m.not) {
+    return {
+      type: 'not',
+      filter: res,
+    } as CommonFilterSpec;
+  }
+  return res;
+}
+export function toOuterModel(m: PlAdvancedFilterUI): CommonFilterSpec {
+  return {
+    type: m.operand,
+    filters: m.groups.map(toOuterFilterGroup),
+  };
+}
+
+export function createNewGroup(selectedSourceId: string) {
+  return {
+    id: getNewGroupId(),
+    not: false,
+    operand: 'and' as const,
+    expanded: true,
+    filters: [{
+      ...DEFAULT_FILTERS[DEFAULT_FILTER_TYPE],
+      column: selectedSourceId as SUniversalPColumnId,
+    }],
+  };
+}
+
+export type NormalizedSpecData = {
+  valueType: ValueType;
+  annotations: PColumnSpec['annotations'];
+  domain: PColumnSpec['domain'];
+};
+export function getNormalizedSpec(spec: PColumnSpec | AxisSpec): NormalizedSpecData {
+  return { valueType: getTypeFromPColumnOrAxisSpec(spec), annotations: spec.annotations, domain: spec.domain };
+}
+
+export function isNumericValueType(spec?: PColumnSpec | AxisSpec): boolean {
+  if (!spec) {
+    return false;
+  }
+  const valueType = getNormalizedSpec(spec).valueType;
+  return valueType === 'Int' || valueType === 'Long' || valueType === 'Float' || valueType === 'Double';
+}
+
+export function isStringValueType(spec?: PColumnSpec | AxisSpec): boolean {
+  if (!spec) {
+    return false;
+  }
+  const valueType = getNormalizedSpec(spec).valueType;
+  return valueType === 'String';
+}
+
+export function isNumericFilter(filter: Filter): filter is Filter & { type: 'equal' | 'notEqual' | 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' } {
+  return filter.type === 'equal' || filter.type === 'notEqual' || filter.type === 'lessThan' || filter.type === 'lessThanOrEqual' || filter.type === 'greaterThan' || filter.type === 'greaterThanOrEqual';
+}
+export function isStringFilter(filter: Filter): filter is Filter & { type: 'patternEquals' | 'patternNotEquals' | 'patternContainSubsequence' | 'patternNotContainSubsequence' | 'patternMatchesRegularExpression' | 'patternFuzzyContainSubsequence' } {
+  return filter.type === 'patternEquals' || filter.type === 'patternNotEquals' || filter.type === 'patternContainSubsequence' || filter.type === 'patternNotContainSubsequence' || filter.type === 'patternMatchesRegularExpression' || filter.type === 'patternFuzzyContainSubsequence';
+}
+
+export function getFilterInfo(filterType: FilterType): { label: string; supportedFor: (spec: NormalizedSpecData) => boolean } {
+  return filterUiMetadata[filterType as keyof typeof filterUiMetadata];
+}
+
+export function useInnerModel<T, V>(
+  toInnerModel: (v: T) => V,
+  toOuterModel: (v: V) => T,
+  model: ModelRef<T>,
+) {
+  const innerModel = ref<V>(toInnerModel(model.value));
+  function updateOuterModelValue(v: V) {
+    model.value = toOuterModel(v);
+  }
+  function updateInnerModelValue(v: T) {
+    innerModel.value = toInnerModel(v);
+  }
+  watch(() => model.value, (v: T) => {
+    updateInnerModelValue(v);
+  }, { deep: true });
+  watch(() => innerModel.value, (v: V) => {
+    updateOuterModelValue(v);
+  }, { deep: true });
+
+  return innerModel;
+}
+
+export function isValidColumnId(id: unknown): id is PlAdvancedFilterColumnId {
+  if (typeof id !== 'string') {
+    return false;
+  }
+  try {
+    const parsedId = parseJson<FilteredPColumnId | AnchoredPColumnId | AxisId>(id as CanonicalizedJson<FilteredPColumnId | AnchoredPColumnId | AxisId>);
+    return isFilteredPColumn(parsedId) || isAnchoredPColumnId(parsedId) || isAxisId(parsedId);
+  } catch {
+    return false;
+  }
+}

package/src/lib.ts

@@ -28,12 +28,12 @@ export * from './components/PlAgGridColumnManager';
 
 export * from './components/PlTableFilters';
 
-export * from './components/PlMultiSequenceAlignment';
-
 export * from './components/PlAnnotations';
 
 export * from './components/PlBtnExportArchive';
 
+export * from './components/PlAdvancedFilter';
+
 export * from './defineApp';
 
 export * from './createModel';