@platforma-sdk/ui-vue 1.45.34 → 1.45.36

package/dist/components/PlAdvancedFilter/SingleFilter.vue2.js

@@ -0,0 +1,306 @@
+import { defineComponent as Z, mergeModels as _, useModel as ee, computed as p, createElementBlock as x, openBlock as n, Fragment as E, createElementVNode as v, createVNode as g, normalizeClass as r, createCommentVNode as b, createBlock as c, unref as a, toDisplayString as le, renderList as te } from "vue";
+import { PlIcon16 as k, PlDropdown as T, PlAutocomplete as D, PlTextField as N, Slider as oe, PlToggleSwitch as ue, PlAutocompleteMulti as ae, PlNumberField as ne } from "@milaboratories/uikit";
+import { SUPPORTED_FILTER_TYPES as se, DEFAULT_FILTERS as A, DEFAULT_FILTER_TYPE as re } from "./constants.js";
+import { parseColumnId as U, isFilteredPColumn as R, stringifyColumnId as q } from "@platforma-sdk/model";
+import ie from "./OperandButton.vue.js";
+import { getNormalizedSpec as z, getFilterInfo as B, isNumericFilter as L, isStringFilter as de } from "./utils.js";
+const pe = ["title"], fe = /* @__PURE__ */ Z({
+  __name: "SingleFilter",
+  props: /* @__PURE__ */ _({
+    operand: {},
+    columnOptions: {},
+    enableDnd: { type: Boolean },
+    isLast: { type: Boolean },
+    getSuggestOptions: { type: Function },
+    getSuggestModel: { type: Function },
+    onDelete: { type: Function },
+    onChangeOperand: { type: Function }
+  }, {
+    modelValue: { required: !0 },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(M) {
+    const y = M, l = ee(M, "modelValue");
+    async function w(e, t, u) {
+      return Promise.all(t.map((d) => y.getSuggestModel({ columnId: e, searchStr: d, axisIdx: u })));
+    }
+    async function h(e, t, u) {
+      return y.getSuggestModel({ columnId: e, searchStr: t, axisIdx: u });
+    }
+    async function C(e, t, u) {
+      return y.getSuggestOptions({ columnId: e, searchStr: t, axisIdx: u });
+    }
+    function W() {
+      const e = B(l.value.type);
+      f.value && e.supportedFor(f.value) && L(l.value) || (f.value && e.supportedFor(f.value) && de(l.value) ? l.value = {
+        ...A[l.value.type],
+        value: l.value.value,
+        column: l.value.column
+      } : l.value = {
+        ...A[l.value.type],
+        column: l.value.column
+      });
+    }
+    function j(e) {
+      if (!e)
+        return;
+      const t = y.columnOptions.find((i) => i.id === $(e));
+      if (!t)
+        return;
+      const u = B(l.value.type), d = z(t == null ? void 0 : t.spec);
+      u.supportedFor(d) ? l.value.column = e : l.value = {
+        ...A[re],
+        column: e
+      };
+    }
+    const S = p(() => y.columnOptions.find((t) => t.id === $(l.value.column)) === void 0), X = p(() => {
+      const e = y.columnOptions.map((t) => ({ value: t.id, label: t.label ?? t }));
+      return S.value && e.unshift({ value: l.value.column, label: "Inconsistent value" }), e;
+    });
+    function $(e) {
+      try {
+        const t = U(e);
+        return R(t) ? q(t.source) : e;
+      } catch {
+        return e;
+      }
+    }
+    function Y(e) {
+      const t = $(e), u = y.columnOptions.find((i) => i.id === t), d = ((u == null ? void 0 : u.axesToBeFixed) ?? []).reduce((i, F) => (i[F.idx] = void 0, i), {});
+      try {
+        const i = U(e);
+        if (R(i))
+          return {
+            source: t,
+            axisFiltersByIndex: i.axisFilters.reduce((F, I) => (F[I[0]] = I[1], F), d)
+          };
+      } catch {
+        return { source: e, axisFiltersByIndex: d };
+      }
+      return { source: e, axisFiltersByIndex: d };
+    }
+    function G(e) {
+      return Object.keys(e.axisFiltersByIndex).length === 0 ? e.source : q({
+        source: U(e.source),
+        axisFilters: Object.entries(e.axisFiltersByIndex).map(([t, u]) => [Number(t), u])
+      });
+    }
+    const s = p({
+      get: () => Y(l.value.column),
+      set: (e) => {
+        l.value.column = G(e);
+      }
+    });
+    function H(e, t) {
+      s.value = {
+        ...s.value,
+        axisFiltersByIndex: { ...s.value.axisFiltersByIndex, [e]: t }
+      };
+    }
+    const m = p(() => y.columnOptions.find((e) => e.id === s.value.source)), f = p(() => {
+      var e;
+      return (e = m.value) != null && e.spec ? z(m.value.spec) : null;
+    }), P = p(() => {
+      var e;
+      return (e = f.value) == null ? void 0 : e.valueType;
+    }), O = p(() => {
+      var e;
+      return ((e = m.value) == null ? void 0 : e.error) || S.value;
+    }), J = p(
+      () => [...se].filter(
+        (e) => l.value.type === e || (f.value ? B(e).supportedFor(f.value) : !0)
+      ).map((e) => ({ value: e, label: B(e).label }))
+    ), K = p(() => {
+      var e, t;
+      return l.value.type === "patternFuzzyContainSubsequence" ? ((e = m.value) == null ? void 0 : e.alphabet) === "nucleotide" ? [{ label: "N", value: "N" }] : ((t = m.value) == null ? void 0 : t.alphabet) === "aminoacid" ? [{ label: "X", value: "X" }] : [...new Set(l.value.value.split(""))].sort().map((u) => ({ value: u, label: u })) : [];
+    }), Q = p(() => {
+      if (l.value.type !== "patternMatchesRegularExpression")
+        return !1;
+      try {
+        return new RegExp(l.value.value), !1;
+      } catch {
+        return !0;
+      }
+    });
+    return (e, t) => {
+      var u, d, i, F, I;
+      return n(), x(E, null, [
+        v("div", {
+          class: r(e.$style.filterWrapper)
+        }, [
+          e.enableDnd ? (n(), x("div", {
+            key: 0,
+            class: r([e.$style.top, e.$style.columnChip, { [e.$style.error]: O.value }])
+          }, [
+            v("div", {
+              class: r([e.$style.typeIcon, { [e.$style.error]: O.value }])
+            }, [
+              O.value ? (n(), c(a(k), {
+                key: 0,
+                name: "warning"
+              })) : (n(), c(a(k), {
+                key: 1,
+                name: P.value === "String" || P.value === void 0 ? "cell-type-txt" : "cell-type-num"
+              }, null, 8, ["name"]))
+            ], 2),
+            v("div", {
+              class: r(e.$style.titleWrapper),
+              title: ((u = m.value) == null ? void 0 : u.label) ?? ""
+            }, [
+              v("div", {
+                class: r(e.$style.title)
+              }, le(S.value ? "Inconsistent value" : ((d = m.value) == null ? void 0 : d.label) ?? l.value.column), 3)
+            ], 10, pe),
+            v("div", {
+              class: r(e.$style.closeIcon),
+              onClick: t[0] || (t[0] = (o) => e.onDelete(l.value.column))
+            }, [
+              g(a(k), { name: "close" })
+            ], 2)
+          ], 2)) : (n(), x("div", {
+            key: 1,
+            class: r(e.$style.top)
+          }, [
+            g(a(T), {
+              modelValue: s.value.source,
+              "onUpdate:modelValue": [
+                t[1] || (t[1] = (o) => s.value.source = o),
+                j
+              ],
+              errorStatus: O.value,
+              options: X.value,
+              style: { width: "100%" },
+              "group-position": "top-left"
+            }, null, 8, ["modelValue", "errorStatus", "options"]),
+            v("div", {
+              class: r(e.$style.closeButton),
+              onClick: t[2] || (t[2] = (o) => e.onDelete(l.value.column))
+            }, [
+              g(a(k), { name: "close" })
+            ], 2)
+          ], 2)),
+          (F = (i = m.value) == null ? void 0 : i.axesToBeFixed) != null && F.length ? (n(), x("div", {
+            key: 2,
+            class: r(e.$style.fixedAxesBlock)
+          }, [
+            (n(!0), x(E, null, te((I = m.value) == null ? void 0 : I.axesToBeFixed, (o) => (n(), c(a(D), {
+              key: o.idx,
+              modelValue: s.value.axisFiltersByIndex[o.idx],
+              "onUpdate:modelValue": [(V) => s.value.axisFiltersByIndex[o.idx] = V, (V) => H(o.idx, V)],
+              label: o.label,
+              "options-search": (V) => C(s.value.source, V, o.idx),
+              "model-search": (V) => h(s.value.source, V, o.idx),
+              disabled: S.value,
+              clearable: !0
+            }, null, 8, ["modelValue", "onUpdate:modelValue", "label", "options-search", "model-search", "disabled"]))), 128))
+          ], 2)) : b("", !0),
+          v("div", {
+            class: r(l.value.type === "isNA" || l.value.type === "isNotNA" ? e.$style.bottom : e.$style.middle)
+          }, [
+            g(a(T), {
+              modelValue: l.value.type,
+              "onUpdate:modelValue": [
+                t[3] || (t[3] = (o) => l.value.type = o),
+                W
+              ],
+              options: J.value,
+              "group-position": l.value.type === "isNA" || l.value.type === "isNotNA" ? "bottom" : "middle"
+            }, null, 8, ["modelValue", "options", "group-position"])
+          ], 2),
+          l.value.type === "patternFuzzyContainSubsequence" ? (n(), x(E, { key: 3 }, [
+            v("div", {
+              class: r(e.$style.middle)
+            }, [
+              g(a(N), {
+                modelValue: l.value.value,
+                "onUpdate:modelValue": t[4] || (t[4] = (o) => l.value.value = o),
+                placeholder: "Substring",
+                "group-position": "middle"
+              }, null, 8, ["modelValue"])
+            ], 2),
+            v("div", {
+              class: r(e.$style.innerSection)
+            }, [
+              g(a(oe), {
+                modelValue: l.value.maxEdits,
+                "onUpdate:modelValue": t[5] || (t[5] = (o) => l.value.maxEdits = o),
+                max: 5,
+                breakpoints: "",
+                label: "Maximum number of substitutions and indels"
+              }, null, 8, ["modelValue"]),
+              g(a(ue), {
+                modelValue: l.value.substitutionsOnly,
+                "onUpdate:modelValue": t[6] || (t[6] = (o) => l.value.substitutionsOnly = o),
+                label: "Substitutions only"
+              }, null, 8, ["modelValue"])
+            ], 2)
+          ], 64)) : b("", !0),
+          v("div", {
+            class: r(e.$style.bottom)
+          }, [
+            l.value.type === "patternEquals" || l.value.type === "patternNotEquals" ? (n(), c(a(D), {
+              key: 0,
+              modelValue: l.value.value,
+              "onUpdate:modelValue": t[7] || (t[7] = (o) => l.value.value = o),
+              "options-search": (o) => C(s.value.source, o),
+              "model-search": (o) => h(s.value.source, o),
+              disabled: S.value,
+              clearable: !0,
+              "group-position": "bottom"
+            }, null, 8, ["modelValue", "options-search", "model-search", "disabled"])) : b("", !0),
+            l.value.type === "inSet" || l.value.type === "notInSet" ? (n(), c(a(ae), {
+              key: 1,
+              modelValue: l.value.value,
+              "onUpdate:modelValue": t[8] || (t[8] = (o) => l.value.value = o),
+              "options-search": (o) => C(s.value.source, o),
+              "model-search": (o) => w(s.value.source, o),
+              disabled: S.value,
+              "group-position": "bottom"
+            }, null, 8, ["modelValue", "options-search", "model-search", "disabled"])) : b("", !0),
+            a(L)(l.value) ? (n(), c(a(ne), {
+              key: 2,
+              modelValue: l.value.x,
+              "onUpdate:modelValue": t[9] || (t[9] = (o) => l.value.x = o),
+              "group-position": "bottom"
+            }, null, 8, ["modelValue"])) : b("", !0),
+            l.value.type === "patternContainSubsequence" || l.value.type === "patternNotContainSubsequence" ? (n(), c(a(N), {
+              key: 3,
+              modelValue: l.value.value,
+              "onUpdate:modelValue": t[10] || (t[10] = (o) => l.value.value = o),
+              placeholder: "Substring",
+              "group-position": "bottom"
+            }, null, 8, ["modelValue"])) : b("", !0),
+            l.value.type === "patternMatchesRegularExpression" ? (n(), c(a(N), {
+              key: 4,
+              modelValue: l.value.value,
+              "onUpdate:modelValue": t[11] || (t[11] = (o) => l.value.value = o),
+              error: Q.value ? "Regular expression is not valid" : void 0,
+              placeholder: "Regular expression",
+              "group-position": "bottom"
+            }, null, 8, ["modelValue", "error"])) : b("", !0),
+            l.value.type === "patternFuzzyContainSubsequence" ? (n(), c(a(T), {
+              key: 5,
+              modelValue: l.value.wildcard,
+              "onUpdate:modelValue": t[12] || (t[12] = (o) => l.value.wildcard = o),
+              clearable: "",
+              placeholder: "Wildcard value",
+              options: K.value,
+              "group-position": "bottom"
+            }, null, 8, ["modelValue", "options"])) : b("", !0)
+          ], 2)
+        ], 2),
+        g(ie, {
+          class: r(e.$style.buttonWrapper),
+          active: e.operand,
+          disabled: e.isLast,
+          "on-select": e.onChangeOperand
+        }, null, 8, ["class", "active", "disabled", "on-select"])
+      ], 64);
+    };
+  }
+});
+export {
+  fe as default
+};
+//# sourceMappingURL=SingleFilter.vue2.js.map

package/dist/components/PlAdvancedFilter/SingleFilter.vue2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleFilter.vue2.js","sources":["../../../src/components/PlAdvancedFilter/SingleFilter.vue"],"sourcesContent":["<script lang=\"ts\" setup>\nimport type { PlAdvancedFilterColumnId, Filter, Operand, SourceOptionInfo } from './types';\nimport { PlIcon16, PlDropdown, PlAutocomplete, PlAutocompleteMulti, PlTextField, PlNumberField, Slider, PlToggleSwitch } from '@milaboratories/uikit';\nimport { computed } from 'vue';\nimport { SUPPORTED_FILTER_TYPES, DEFAULT_FILTER_TYPE, DEFAULT_FILTERS } from './constants';\nimport type { AnchoredPColumnId, AxisFilterByIdx, AxisFilterValue, SUniversalPColumnId } from '@platforma-sdk/model';\nimport { isFilteredPColumn, parseColumnId, stringifyColumnId, type ListOptionBase } from '@platforma-sdk/model';\nimport OperandButton from './OperandButton.vue';\nimport { getFilterInfo, getNormalizedSpec, isNumericFilter, isStringFilter } from './utils';\n\nconst props = defineProps<{\n  operand: Operand;\n  columnOptions: SourceOptionInfo[];\n  enableDnd: boolean;\n  isLast: boolean;\n  getSuggestOptions: (params: { columnId: PlAdvancedFilterColumnId; searchStr: string; axisIdx?: number }) => (Promise<ListOptionBase<string | number>[]>) |\n    ((params: { columnId: SUniversalPColumnId; searchStr: string; axisIdx?: number }) => ListOptionBase<string | number>[]);\n  getSuggestModel: (params: { columnId: PlAdvancedFilterColumnId; searchStr: string; axisIdx?: number }) => (Promise<ListOptionBase<string | number>>) |\n    ((params: { columnId: PlAdvancedFilterColumnId; searchStr: string; axisIdx?: number }) => ListOptionBase<string | number>);\n  onDelete: (columnId: PlAdvancedFilterColumnId) => void;\n  onChangeOperand: (op: Operand) => void;\n}>();\n\nconst filter = defineModel<Filter>({ required: true });\n\nasync function getSuggestModelMultiFn(id: PlAdvancedFilterColumnId, v: string[], axisIdx?: number): Promise<ListOptionBase<string>[]> {\n  return Promise.all(v.map((v) => props.getSuggestModel({ columnId: id, searchStr: v, axisIdx }) as Promise<ListOptionBase<string>>));\n}\nasync function getSuggestModelSingleFn(id: PlAdvancedFilterColumnId, v: string, axisIdx?: number): Promise<ListOptionBase<string>> {\n  return props.getSuggestModel({ columnId: id, searchStr: v, axisIdx }) as Promise<ListOptionBase<string>>;\n}\nasync function getSuggestOptionsFn(id: PlAdvancedFilterColumnId, str: string, axisIdx?: number): Promise<ListOptionBase<string>[]> {\n  return props.getSuggestOptions({ columnId: id, searchStr: str, axisIdx }) as Promise<ListOptionBase<string>[]>;\n}\n\nfunction changeFilterType() {\n  const nextFilterInfo = getFilterInfo(filter.value.type);\n  if (currentSpec.value && nextFilterInfo.supportedFor(currentSpec.value) && isNumericFilter(filter.value)) {\n    // no extra changes, previous filter is compatible with new filter type\n    return;\n  } else if (currentSpec.value && nextFilterInfo.supportedFor(currentSpec.value) && isStringFilter(filter.value)) {\n    // erase extra settings for string filter types, save only value and column (for example regex)\n    filter.value = {\n      ...DEFAULT_FILTERS[filter.value.type],\n      value: filter.value.value,\n      column: filter.value.column,\n    } as Filter;\n  } else {\n    filter.value = {\n      ...DEFAULT_FILTERS[filter.value.type],\n      column: filter.value.column,\n    };\n  }\n}\n\nfunction changeSourceId(newSourceId?: PlAdvancedFilterColumnId) {\n  if (!newSourceId) {\n    return;\n  }\n  const newSourceInfo = props.columnOptions.find((v) => v.id === getSourceId(newSourceId));\n  if (!newSourceInfo) {\n    return;\n  }\n  const filterInfo = getFilterInfo(filter.value.type);\n  const newSourceSpec = getNormalizedSpec(newSourceInfo?.spec);\n  if (filterInfo.supportedFor(newSourceSpec)) { // don't do anything except update source id\n    filter.value.column = newSourceId;\n  } else { // reset to default filter which fits to any column\n    filter.value = {\n      ...DEFAULT_FILTERS[DEFAULT_FILTER_TYPE],\n      column: newSourceId,\n    };\n  }\n}\n\nconst inconsistentSourceSelected = computed(() => {\n  const selectedOption = props.columnOptions.find((op) => op.id === getSourceId(filter.value.column));\n  return selectedOption === undefined;\n});\nconst sourceOptions = computed(() => {\n  const options = props.columnOptions.map((v) => ({ value: v.id, label: v.label ?? v }));\n  if (inconsistentSourceSelected.value) {\n    options.unshift({ value: filter.value.column, label: 'Inconsistent value' });\n  }\n  return options;\n});\n\nfunction getSourceId(column: PlAdvancedFilterColumnId): PlAdvancedFilterColumnId {\n  try {\n    const parsedColumnId = parseColumnId(column as SUniversalPColumnId);\n    if (isFilteredPColumn(parsedColumnId)) {\n      return stringifyColumnId(parsedColumnId.source);\n    } else {\n      return column;\n    }\n  } catch {\n    return column;\n  }\n}\n\n// similar to FilteredPColumnId but source is stringified and axis filters can be undefined\ntype ColumnAsSourceAndFixedAxes = { source: PlAdvancedFilterColumnId; axisFiltersByIndex: Record<number, AxisFilterValue | undefined> };\nfunction getColumnAsSourceAndFixedAxes(column: PlAdvancedFilterColumnId): ColumnAsSourceAndFixedAxes {\n  const sourceId = getSourceId(column);\n  const option = props.columnOptions.find((op) => op.id === sourceId);\n  const axesToBeFixed = (option?.axesToBeFixed ?? []).reduce((res, item) => {\n    res[item.idx] = undefined;\n    return res;\n  }, {} as Record<number, AxisFilterValue | undefined>);\n  try {\n    const parsedColumnId = parseColumnId(column as SUniversalPColumnId);\n    if (isFilteredPColumn(parsedColumnId)) {\n      return {\n        source: sourceId,\n        axisFiltersByIndex: parsedColumnId.axisFilters.reduce((res, item) => {\n          res[item[0]] = item[1];\n          return res;\n        }, axesToBeFixed),\n      };\n    }\n  } catch {\n    return { source: column, axisFiltersByIndex: axesToBeFixed };\n  }\n  return { source: column, axisFiltersByIndex: axesToBeFixed };\n}\n\nfunction stringifyColumn(value: ColumnAsSourceAndFixedAxes): PlAdvancedFilterColumnId {\n  if (Object.keys(value.axisFiltersByIndex).length === 0) {\n    return value.source;\n  }\n  return stringifyColumnId({\n    source: parseColumnId(value.source as SUniversalPColumnId) as AnchoredPColumnId,\n    axisFilters: Object.entries(value.axisFiltersByIndex).map(([idx, value]) => [Number(idx), value] as AxisFilterByIdx),\n  });\n}\n\nconst columnAsSourceAndFixedAxes = computed({\n  get: () => {\n    return getColumnAsSourceAndFixedAxes(filter.value.column);\n  },\n  set: (value) => {\n    filter.value.column = stringifyColumn(value);\n  },\n});\nfunction updateAxisFilterValue(idx: number, value: AxisFilterValue | undefined) {\n  columnAsSourceAndFixedAxes.value = {\n    ...columnAsSourceAndFixedAxes.value,\n    axisFiltersByIndex: { ...columnAsSourceAndFixedAxes.value.axisFiltersByIndex, [idx]: value } };\n}\n\nconst currentOption = computed(() => props.columnOptions.find((op) => op.id === columnAsSourceAndFixedAxes.value.source));\nconst currentSpec = computed(() => currentOption.value?.spec ? getNormalizedSpec(currentOption.value.spec) : null);\nconst currentType = computed(() => currentSpec.value?.valueType);\nconst currentError = computed(() => currentOption.value?.error || inconsistentSourceSelected.value);\n\nconst filterTypesOptions = computed(() => [...SUPPORTED_FILTER_TYPES].filter((v) =>\n  filter.value.type === v || (currentSpec.value ? getFilterInfo(v).supportedFor(currentSpec.value) : true),\n).map((v) => ({ value: v, label: getFilterInfo(v).label })),\n);\n\nconst wildcardOptions = computed(() => {\n  if (filter.value.type === 'patternFuzzyContainSubsequence') {\n    if (currentOption.value?.alphabet === 'nucleotide') {\n      return [{ label: 'N', value: 'N' }];\n    }\n    if (currentOption.value?.alphabet === 'aminoacid') {\n      return [{ label: 'X', value: 'X' }];\n    }\n    return [...new Set(filter.value.value.split(''))].sort().map((v) => ({ value: v, label: v }));\n  }\n  return [];\n});\n\nconst stringMatchesError = computed(() => {\n  if (filter.value.type !== 'patternMatchesRegularExpression') {\n    return false;\n  }\n  try {\n    new RegExp(filter.value.value);\n    return false;\n  } catch {\n    return true;\n  }\n});\n\n</script>\n<template>\n  <div :class=\"$style.filterWrapper\">\n    <!-- top element - column selector / column label - for all filter types-->\n    <div v-if=\"enableDnd\" :class=\"[$style.top, $style.columnChip, {[$style.error]: currentError}]\">\n      <div :class=\"[$style.typeIcon, {[$style.error]: currentError}]\">\n        <PlIcon16 v-if=\"currentError\" name=\"warning\"/>\n        <PlIcon16 v-else :name=\"currentType === 'String' || currentType === undefined ? 'cell-type-txt' : 'cell-type-num'\"/>\n      </div>\n      <div :class=\"$style.titleWrapper\" :title=\"currentOption?.label ?? ''\">\n        <div :class=\"$style.title\">\n          {{ inconsistentSourceSelected ? 'Inconsistent value' : currentOption?.label ?? filter.column }}\n        </div>\n      </div>\n      <div :class=\"$style.closeIcon\" @click=\"onDelete(filter.column)\">\n        <PlIcon16 name=\"close\"/>\n      </div>\n    </div>\n    <div v-else :class=\"$style.top\" >\n      <PlDropdown\n        v-model=\"columnAsSourceAndFixedAxes.source\"\n        :errorStatus=\"currentError\"\n        :options=\"sourceOptions\"\n        :style=\"{width: '100%'}\"\n        group-position=\"top-left\"\n        @update:model-value=\"changeSourceId\"\n      />\n      <div :class=\"$style.closeButton\" @click=\"onDelete(filter.column)\">\n        <PlIcon16 name=\"close\"/>\n      </div>\n    </div>\n\n    <div v-if=\"currentOption?.axesToBeFixed?.length\" :class=\"$style.fixedAxesBlock\">\n      <template v-for=\"value in currentOption?.axesToBeFixed\" :key=\"value.idx\">\n        <PlAutocomplete\n          v-model=\"columnAsSourceAndFixedAxes.axisFiltersByIndex[value.idx]\"\n          :label=\"value.label\"\n          :options-search=\"(str) => getSuggestOptionsFn(columnAsSourceAndFixedAxes.source, str, value.idx)\"\n          :model-search=\"(v) => getSuggestModelSingleFn(columnAsSourceAndFixedAxes.source, v as string, value.idx)\"\n          :disabled=\"inconsistentSourceSelected\"\n          :clearable=\"true\"\n          @update:model-value=\"(v) => updateAxisFilterValue(value.idx, v)\"\n        />\n      </template>\n    </div>\n\n    <!-- middle - filter type selector -  for all filter types -->\n    <div :class=\"filter.type === 'isNA' || filter.type === 'isNotNA' ? $style.bottom : $style.middle\">\n      <PlDropdown\n        v-model=\"filter.type\"\n        :options=\"filterTypesOptions\"\n        :group-position=\"filter.type === 'isNA' || filter.type === 'isNotNA' ? 'bottom' : 'middle'\"\n        @update:model-value=\"changeFilterType\"\n      />\n    </div>\n\n    <!-- middle - for fuzzy contains filter -->\n    <template v-if=\"filter.type === 'patternFuzzyContainSubsequence'\">\n      <div :class=\"$style.middle\">\n        <PlTextField\n          v-model=\"filter.value\"\n          placeholder=\"Substring\"\n          group-position=\"middle\"\n        />\n      </div>\n      <div :class=\"$style.innerSection\">\n        <Slider\n          v-model=\"filter.maxEdits\"\n          :max=\"5\"\n          breakpoints label=\"Maximum number of substitutions and indels\"\n        />\n        <PlToggleSwitch\n          v-model=\"filter.substitutionsOnly\"\n          label=\"Substitutions only\"\n        />\n      </div>\n    </template>\n\n    <!-- bottom element - individual settings for every filter type -->\n    <div :class=\"$style.bottom\">\n      <template v-if=\"filter.type === 'patternEquals' || filter.type === 'patternNotEquals'\" >\n        <PlAutocomplete\n          v-model=\"filter.value\"\n          :options-search=\"(str) => getSuggestOptionsFn(columnAsSourceAndFixedAxes.source, str)\"\n          :model-search=\"(v) => getSuggestModelSingleFn(columnAsSourceAndFixedAxes.source, v as string)\"\n          :disabled=\"inconsistentSourceSelected\"\n          :clearable=\"true\"\n          group-position=\"bottom\"\n        />\n      </template>\n      <template v-if=\"filter.type === 'inSet' || filter.type === 'notInSet'\" >\n        <PlAutocompleteMulti\n          v-model=\"filter.value\"\n          :options-search=\"(str) => getSuggestOptionsFn(columnAsSourceAndFixedAxes.source, str)\"\n          :model-search=\"(v) => getSuggestModelMultiFn(columnAsSourceAndFixedAxes.source, v as string[])\"\n          :disabled=\"inconsistentSourceSelected\"\n          group-position=\"bottom\"\n        />\n      </template>\n      <PlNumberField\n        v-if=\"isNumericFilter(filter)\"\n        v-model=\"filter.x\"\n        group-position=\"bottom\"\n      />\n      <PlTextField\n        v-if=\"filter.type === 'patternContainSubsequence' || filter.type === 'patternNotContainSubsequence'\"\n        v-model=\"filter.value\"\n        placeholder=\"Substring\"\n        group-position=\"bottom\"\n      />\n      <PlTextField\n        v-if=\"filter.type === 'patternMatchesRegularExpression'\"\n        v-model=\"filter.value\"\n        :error=\"stringMatchesError ? 'Regular expression is not valid' : undefined\"\n        placeholder=\"Regular expression\"\n        group-position=\"bottom\"\n      />\n      <PlDropdown\n        v-if=\"filter.type === 'patternFuzzyContainSubsequence'\"\n        v-model=\"filter.wildcard\"\n        clearable\n        placeholder=\"Wildcard value\"\n        :options=\"wildcardOptions\"\n        group-position=\"bottom\"\n      />\n    </div>\n  </div>\n  <OperandButton\n    :class=\"$style.buttonWrapper\"\n    :active=\"operand\"\n    :disabled=\"isLast\"\n    :on-select=\"onChangeOperand\"\n  />\n</template>\n\n<style module>\n.filterWrapper {\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  margin-bottom: 8px;\n  width: 100%;\n  cursor: default;\n}\n\n.typeIcon {\n  display: inline-flex;\n  margin-right: 8px;\n}\n\n.typeIcon.error {\n  --icon-color: var(--txt-error);\n}\n\n.closeIcon {\n  display: inline-flex;\n  margin-left: 12px;\n  cursor: pointer;\n}\n\n.titleWrapper {\n  flex-grow: 1;\n  overflow: hidden;\n}\n.title {\n  overflow: hidden;\n  color: var(--txt-01);\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  font-size: 14px;\n  font-weight: 500;\n  line-height: 20px;\n}\n\n.columnChip {\n  width: 100%;\n  display: flex;\n  padding: 10px 12px;\n  align-items: center;\n  border-radius: 6px;\n  border: 1px solid var(--txt-01);\n  border-bottom-right-radius: 0;\n  border-bottom-left-radius: 0;\n\n  &.error {\n    border-color: var(--txt-error);\n  }\n}\n\n.innerSection {\n  border: 1px solid var(--txt-01);\n  border-top: none;\n  padding: 16px 12px;\n}\n\n.closeButton {\n  border: 1px solid var(--txt-01);\n  border-top-right-radius: 6px;\n  border-left: none;\n  width: 40px;\n  height: 40px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  flex-shrink: 0;\n  cursor: pointer;\n}\n\n.top {\n  position: relative;\n  display: flex;\n  width: 100%;\n  z-index: 1;\n  background: #fff;\n}\n\n.fixedAxesBlock {\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  padding: 12px 8px;\n  gap: 12px;\n  border-left: 1px solid var(--txt-01);\n  border-right: 1px solid var(--txt-01);\n}\n\n.fixedAxesBlock > * {\n  background: #fff;\n}\n\n.middle, .bottom {\n  position: relative;\n  margin-top: -1px;\n  background: #fff;\n}\n\n.buttonWrapper {\n  margin-bottom: 8px;\n}\n</style>\n"],"names":["props","__props","filter","_useModel","getSuggestModelMultiFn","id","v","axisIdx","getSuggestModelSingleFn","getSuggestOptionsFn","str","changeFilterType","nextFilterInfo","getFilterInfo","currentSpec","isNumericFilter","isStringFilter","DEFAULT_FILTERS","changeSourceId","newSourceId","newSourceInfo","getSourceId","filterInfo","newSourceSpec","getNormalizedSpec","DEFAULT_FILTER_TYPE","inconsistentSourceSelected","computed","op","sourceOptions","options","column","parsedColumnId","parseColumnId","isFilteredPColumn","stringifyColumnId","getColumnAsSourceAndFixedAxes","sourceId","option","axesToBeFixed","res","item","stringifyColumn","value","idx","columnAsSourceAndFixedAxes","updateAxisFilterValue","currentOption","_a","currentType","currentError","filterTypesOptions","SUPPORTED_FILTER_TYPES","wildcardOptions","_b","stringMatchesError"],"mappings":"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"}

package/dist/components/PlAdvancedFilter/SingleFilter.vue3.js

@@ -0,0 +1,35 @@
+(function(){"use strict";try{if(typeof document<"u"){var o=document.createElement("style");o.appendChild(document.createTextNode("._filterWrapper_mviuo_2{position:relative;display:flex;flex-direction:column;margin-bottom:8px;width:100%;cursor:default}._typeIcon_mviuo_11{display:inline-flex;margin-right:8px}._typeIcon_mviuo_11._error_mviuo_16{--icon-color: var(--txt-error)}._closeIcon_mviuo_20{display:inline-flex;margin-left:12px;cursor:pointer}._titleWrapper_mviuo_26{flex-grow:1;overflow:hidden}._title_mviuo_26{overflow:hidden;color:var(--txt-01);text-overflow:ellipsis;white-space:nowrap;font-size:14px;font-weight:500;line-height:20px}._columnChip_mviuo_40{width:100%;display:flex;padding:10px 12px;align-items:center;border:1px solid var(--txt-01);border-radius:6px 6px 0 0}._columnChip_mviuo_40._error_mviuo_16{border-color:var(--txt-error)}._innerSection_mviuo_55{border:1px solid var(--txt-01);border-top:none;padding:16px 12px}._closeButton_mviuo_61{border:1px solid var(--txt-01);border-top-right-radius:6px;border-left:none;width:40px;height:40px;display:flex;justify-content:center;align-items:center;flex-shrink:0;cursor:pointer}._top_mviuo_74{position:relative;display:flex;width:100%;z-index:1;background:#fff}._fixedAxesBlock_mviuo_82{position:relative;display:flex;flex-direction:column;padding:12px 8px;gap:12px;border-left:1px solid var(--txt-01);border-right:1px solid var(--txt-01)}._fixedAxesBlock_mviuo_82>*{background:#fff}._middle_mviuo_96,._bottom_mviuo_96{position:relative;margin-top:-1px;background:#fff}._buttonWrapper_mviuo_102{margin-bottom:8px}")),document.head.appendChild(o)}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
+const o = "_filterWrapper_mviuo_2", t = "_typeIcon_mviuo_11", e = "_error_mviuo_16", _ = "_closeIcon_mviuo_20", n = "_titleWrapper_mviuo_26", i = "_title_mviuo_26", c = "_columnChip_mviuo_40", r = "_innerSection_mviuo_55", p = "_closeButton_mviuo_61", l = "_top_mviuo_74", s = "_fixedAxesBlock_mviuo_82", u = "_middle_mviuo_96", m = "_bottom_mviuo_96", v = "_buttonWrapper_mviuo_102", a = {
+  filterWrapper: o,
+  typeIcon: t,
+  error: e,
+  closeIcon: _,
+  titleWrapper: n,
+  title: i,
+  columnChip: c,
+  innerSection: r,
+  closeButton: p,
+  top: l,
+  fixedAxesBlock: s,
+  middle: u,
+  bottom: m,
+  buttonWrapper: v
+};
+export {
+  m as bottom,
+  v as buttonWrapper,
+  p as closeButton,
+  _ as closeIcon,
+  c as columnChip,
+  a as default,
+  e as error,
+  o as filterWrapper,
+  s as fixedAxesBlock,
+  r as innerSection,
+  u as middle,
+  i as title,
+  n as titleWrapper,
+  l as top,
+  t as typeIcon
+};
+//# sourceMappingURL=SingleFilter.vue3.js.map

package/dist/components/PlAdvancedFilter/SingleFilter.vue3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleFilter.vue3.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/components/PlAdvancedFilter/constants.d.ts

@@ -0,0 +1,4 @@
+import { Filter, FilterType, SupportedFilterTypes } from './types';
+export declare const SUPPORTED_FILTER_TYPES: Set<SupportedFilterTypes>;
+export declare const DEFAULT_FILTER_TYPE: FilterType;
+export declare const DEFAULT_FILTERS: Record<SupportedFilterTypes, Filter>;

package/dist/components/PlAdvancedFilter/constants.js

@@ -0,0 +1,41 @@
+const t = /* @__PURE__ */ new Set([
+  "isNA",
+  "isNotNA",
+  "greaterThan",
+  "greaterThanOrEqual",
+  "lessThan",
+  "lessThanOrEqual",
+  "patternEquals",
+  "patternNotEquals",
+  "patternContainSubsequence",
+  "patternNotContainSubsequence",
+  "equal",
+  "notEqual",
+  "patternFuzzyContainSubsequence",
+  "patternMatchesRegularExpression",
+  "inSet",
+  "notInSet"
+]), a = "isNA", e = { column: "" }, n = {
+  isNA: { type: "isNA", ...e },
+  isNotNA: { type: "isNotNA", ...e },
+  lessThan: { type: "lessThan", x: void 0, ...e },
+  lessThanOrEqual: { type: "lessThanOrEqual", x: void 0, ...e },
+  patternEquals: { type: "patternEquals", value: void 0, ...e },
+  patternNotEquals: { type: "patternNotEquals", value: void 0, ...e },
+  greaterThan: { type: "greaterThan", x: void 0, ...e },
+  greaterThanOrEqual: { type: "greaterThanOrEqual", x: void 0, ...e },
+  patternContainSubsequence: { type: "patternContainSubsequence", value: "", ...e },
+  patternNotContainSubsequence: { type: "patternNotContainSubsequence", value: "", ...e },
+  patternFuzzyContainSubsequence: { type: "patternFuzzyContainSubsequence", maxEdits: 2, substitutionsOnly: !1, wildcard: void 0, value: "", ...e },
+  patternMatchesRegularExpression: { type: "patternMatchesRegularExpression", value: "", ...e },
+  equal: { type: "equal", x: void 0, ...e },
+  notEqual: { type: "notEqual", x: void 0, ...e },
+  inSet: { type: "inSet", value: [], ...e },
+  notInSet: { type: "notInSet", value: [], ...e }
+};
+export {
+  n as DEFAULT_FILTERS,
+  a as DEFAULT_FILTER_TYPE,
+  t as SUPPORTED_FILTER_TYPES
+};
+//# sourceMappingURL=constants.js.map

package/dist/components/PlAdvancedFilter/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../src/components/PlAdvancedFilter/constants.ts"],"sourcesContent":["import type { PlAdvancedFilterColumnId, Filter, FilterType, SupportedFilterTypes } from './types';\n\nexport const SUPPORTED_FILTER_TYPES = new Set<SupportedFilterTypes>([\n  'isNA',\n  'isNotNA',\n  'greaterThan',\n  'greaterThanOrEqual',\n  'lessThan',\n  'lessThanOrEqual',\n  'patternEquals',\n  'patternNotEquals',\n  'patternContainSubsequence',\n  'patternNotContainSubsequence',\n  'equal',\n  'notEqual',\n  'patternFuzzyContainSubsequence',\n  'patternMatchesRegularExpression',\n  'inSet',\n  'notInSet',\n]);\n\nexport const DEFAULT_FILTER_TYPE: FilterType = 'isNA';\n\nconst emptyCommonPart = { column: '' as PlAdvancedFilterColumnId };\nexport const DEFAULT_FILTERS: Record<SupportedFilterTypes, Filter> = {\n  isNA: { type: 'isNA', ...emptyCommonPart },\n  isNotNA: { type: 'isNotNA', ...emptyCommonPart },\n  lessThan: { type: 'lessThan', x: undefined, ...emptyCommonPart },\n  lessThanOrEqual: { type: 'lessThanOrEqual', x: undefined, ...emptyCommonPart },\n  patternEquals: { type: 'patternEquals', value: undefined, ...emptyCommonPart },\n  patternNotEquals: { type: 'patternNotEquals', value: undefined, ...emptyCommonPart },\n  greaterThan: { type: 'greaterThan', x: undefined, ...emptyCommonPart },\n  greaterThanOrEqual: { type: 'greaterThanOrEqual', x: undefined, ...emptyCommonPart },\n  patternContainSubsequence: { type: 'patternContainSubsequence', value: '', ...emptyCommonPart },\n  patternNotContainSubsequence: { type: 'patternNotContainSubsequence', value: '', ...emptyCommonPart },\n  patternFuzzyContainSubsequence: { type: 'patternFuzzyContainSubsequence', maxEdits: 2, substitutionsOnly: false, wildcard: undefined, value: '', ...emptyCommonPart },\n  patternMatchesRegularExpression: { type: 'patternMatchesRegularExpression', value: '', ...emptyCommonPart },\n  equal: { type: 'equal', x: undefined, ...emptyCommonPart },\n  notEqual: { type: 'notEqual', x: undefined, ...emptyCommonPart },\n  inSet: { type: 'inSet', value: [], ...emptyCommonPart },\n  notInSet: { type: 'notInSet', value: [], ...emptyCommonPart },\n};\n"],"names":["SUPPORTED_FILTER_TYPES","DEFAULT_FILTER_TYPE","emptyCommonPart","DEFAULT_FILTERS"],"mappings":"AAEO,MAAMA,wBAA6B,IAA0B;AAAA,EAClE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC,GAEYC,IAAkC,QAEzCC,IAAkB,EAAE,QAAQ,GAAA,GACrBC,IAAwD;AAAA,EACnE,MAAM,EAAE,MAAM,QAAQ,GAAGD,EAAA;AAAA,EACzB,SAAS,EAAE,MAAM,WAAW,GAAGA,EAAA;AAAA,EAC/B,UAAU,EAAE,MAAM,YAAY,GAAG,QAAW,GAAGA,EAAA;AAAA,EAC/C,iBAAiB,EAAE,MAAM,mBAAmB,GAAG,QAAW,GAAGA,EAAA;AAAA,EAC7D,eAAe,EAAE,MAAM,iBAAiB,OAAO,QAAW,GAAGA,EAAA;AAAA,EAC7D,kBAAkB,EAAE,MAAM,oBAAoB,OAAO,QAAW,GAAGA,EAAA;AAAA,EACnE,aAAa,EAAE,MAAM,eAAe,GAAG,QAAW,GAAGA,EAAA;AAAA,EACrD,oBAAoB,EAAE,MAAM,sBAAsB,GAAG,QAAW,GAAGA,EAAA;AAAA,EACnE,2BAA2B,EAAE,MAAM,6BAA6B,OAAO,IAAI,GAAGA,EAAA;AAAA,EAC9E,8BAA8B,EAAE,MAAM,gCAAgC,OAAO,IAAI,GAAGA,EAAA;AAAA,EACpF,gCAAgC,EAAE,MAAM,kCAAkC,UAAU,GAAG,mBAAmB,IAAO,UAAU,QAAW,OAAO,IAAI,GAAGA,EAAA;AAAA,EACpJ,iCAAiC,EAAE,MAAM,mCAAmC,OAAO,IAAI,GAAGA,EAAA;AAAA,EAC1F,OAAO,EAAE,MAAM,SAAS,GAAG,QAAW,GAAGA,EAAA;AAAA,EACzC,UAAU,EAAE,MAAM,YAAY,GAAG,QAAW,GAAGA,EAAA;AAAA,EAC/C,OAAO,EAAE,MAAM,SAAS,OAAO,CAAA,GAAI,GAAGA,EAAA;AAAA,EACtC,UAAU,EAAE,MAAM,YAAY,OAAO,CAAA,GAAI,GAAGA,EAAA;AAC9C;"}

package/dist/components/PlAdvancedFilter/index.d.ts

@@ -0,0 +1 @@
+export { default as PlAdvancedFilter } from './PlAdvancedFilter.vue';

package/dist/components/PlAdvancedFilter/types.d.ts

@@ -0,0 +1,57 @@
+import { AxisSpec, FilterSpec, FilterSpecLeaf, FilterSpecType, ListOptionBase, PColumnSpec, SUniversalPColumnId, CanonicalizedJson, AxisId } from '@platforma-sdk/model';
+export type PlAdvancedFilterColumnId = SUniversalPColumnId | CanonicalizedJson<AxisId>;
+export type CommonFilterSpec = FilterSpec<FilterSpecLeaf<PlAdvancedFilterColumnId>, {
+    expanded?: boolean;
+}>;
+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 declare function isSupportedFilterType(type: FilterSpecType | undefined): type is 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);
+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;
+};
+export {};

package/dist/components/PlAdvancedFilter/types.js

@@ -0,0 +1,8 @@
+import { SUPPORTED_FILTER_TYPES as e } from "./constants.js";
+function i(r) {
+  return r ? e.has(r) : !1;
+}
+export {
+  i as isSupportedFilterType
+};
+//# sourceMappingURL=types.js.map

package/dist/components/PlAdvancedFilter/types.js.map

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