@milaboratories/uikit 2.4.29 → 2.5.0

package/src/components/PlTextField/PlTextField.vue

@@ -8,17 +8,18 @@ export default {
 </script>
 
 <script lang="ts" setup generic="M, E = string, C = E">
-import './pl-text-field.scss';
+import type { Equal } from '@milaboratories/helpers';
 import { computed, reactive, ref, useSlots } from 'vue';
-import { PlTooltip } from '../PlTooltip';
+import SvgRequired from '../../assets/images/required.svg?raw';
+import { getErrorMessage } from '../../helpers/error.ts';
 import DoubleContour from '../../utils/DoubleContour.vue';
 import { useLabelNotch } from '../../utils/useLabelNotch';
 import { useValidation } from '../../utils/useValidation';
 import { PlIcon16 } from '../PlIcon16';
 import { PlMaskIcon24 } from '../PlMaskIcon24';
-import type { Equal } from '@milaboratories/helpers';
-import SvgRequired from '../../generated/components/svg/images/SvgRequired.vue';
-import { getErrorMessage } from '../../helpers/error.ts';
+import { PlSvg } from '../PlSvg';
+import { PlTooltip } from '../PlTooltip';
+import './pl-text-field.scss';
 
 const slots = useSlots();
 
@@ -191,7 +192,7 @@ useLabelNotch(rootRef);
       }"
     >
       <label v-if="label" ref="label">
-        <SvgRequired v-if="required" />
+        <PlSvg v-if="required" :uri="SvgRequired" />
         <span>{{ label }}</span>
         <PlTooltip v-if="slots.tooltip" class="info" position="top">
           <template #tooltip>

package/src/composition/filters/index.ts

@@ -0,0 +1,2 @@
+export * from './metadata';
+export * from './types';

package/src/composition/filters/metadata.ts

@@ -0,0 +1,476 @@
+import type { FilterSpecType, SimplifiedPColumnSpec } from '@platforma-sdk/model';
+import type { FilterSpecMetadataRecord } from './types';
+
+export const filterUiMetadata = {
+  equal: {
+    label: 'Col = X (Equal)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'equal',
+      },
+      x: {
+        label: 'X',
+        fieldType: 'number',
+        defaultValue: () => 0,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  lessThan: {
+    label: 'Col < X (Less Than)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'lessThan',
+      },
+      x: {
+        label: 'X',
+        fieldType: 'number',
+        defaultValue: () => 0,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  greaterThan: {
+    label: 'Col > X (Greater Than)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'greaterThan',
+      },
+      x: {
+        label: 'X',
+        fieldType: 'number',
+        defaultValue: () => 0,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  lessThanOrEqual: {
+    label: 'Col ≤ X (Less Than or Equal)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'lessThanOrEqual',
+      },
+      x: {
+        label: 'X',
+        fieldType: 'number',
+        defaultValue: () => 0,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  greaterThanOrEqual: {
+    label: 'Col ≥ X (Greater Than or Equal)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'greaterThanOrEqual',
+      },
+      x: {
+        label: 'X',
+        fieldType: 'number',
+        defaultValue: () => 0,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  // Columns comparison
+  equalToColumn: {
+    label: 'Col₁ = Col₂ (Compare Columns)',
+    form: {
+      column: {
+        label: 'Col₁',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'equalToColumn',
+      },
+      rhs: {
+        label: 'Col₂',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
+      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
+    },
+  },
+  lessThanColumn: {
+    label: 'Col₁ < Col₂ (Compare Columns)',
+    form: {
+      column: {
+        label: 'Col₁',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'lessThanColumn',
+      },
+      rhs: {
+        label: 'Col₂',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      minDiff: {
+        label: 'Margin (positive)',
+        fieldType: 'number?',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
+      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
+    },
+  },
+  greaterThanColumn: {
+    label: 'Col₁ > Col₂ (Compare Columns)',
+    form: {
+      column: {
+        label: 'Col₁',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'greaterThanColumn',
+      },
+      rhs: {
+        label: 'Col₂',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      minDiff: {
+        label: 'Margin (positive)',
+        fieldType: 'number?',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
+      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
+    },
+  },
+  lessThanColumnOrEqual: {
+    label: 'Col₁ ≤ Col₂ (Compare Columns)',
+    form: {
+      column: {
+        label: 'Col₁',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'lessThanColumnOrEqual',
+      },
+      rhs: {
+        label: 'Col₂',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      minDiff: {
+        label: 'Margin (positive)',
+        fieldType: 'number?',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
+      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
+    },
+  },
+  greaterThanColumnOrEqual: {
+    label: 'Col₁ ≥ Col₂ (Compare Columns)',
+    form: {
+      column: {
+        label: 'Col₁',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'greaterThanColumnOrEqual',
+      },
+      rhs: {
+        label: 'Col₂',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      minDiff: {
+        label: 'Margin (positive)',
+        fieldType: 'number?',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2?: SimplifiedPColumnSpec): boolean => {
+      return isNumericValueType(spec1) && (spec2 === undefined || isNumericValueType(spec2));
+    },
+  },
+  // Ordering filters
+  topN: {
+    label: 'Top N',
+    form: {
+      column: {
+        label: 'Rank By Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'topN',
+      },
+      n: {
+        label: 'N',
+        fieldType: 'number',
+        defaultValue: () => 10,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  bottomN: {
+    label: 'Bottom N',
+    form: {
+      column: {
+        label: 'Rank By Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'bottomN',
+      },
+      n: {
+        label: 'N',
+        fieldType: 'number',
+        defaultValue: () => 10,
+      },
+    },
+    supportedFor: isNumericValueType,
+  },
+  patternContainSubsequence: {
+    label: 'Col ~ Seq (Contain Subsequence)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'patternContainSubsequence',
+      },
+      value: {
+        label: 'Seq',
+        fieldType: 'string',
+        defaultValue: () => '',
+      },
+    },
+    supportedFor: isStringValueType,
+  },
+  patternNotContainSubsequence: {
+    label: 'Col ≁ Seq (Not Contain Subsequence)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'patternNotContainSubsequence',
+      },
+      value: {
+        label: 'Seq',
+        fieldType: 'string',
+        defaultValue: () => '',
+      },
+    },
+    supportedFor: isStringValueType,
+  },
+  patternEquals: {
+    label: 'Col = Seq (Equals)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'patternEquals',
+      },
+      value: {
+        label: 'Seq',
+        fieldType: 'string',
+        defaultValue: () => '',
+      },
+    },
+    supportedFor: isStringValueType,
+  },
+  patternNotEquals: {
+    label: 'Col ≠ Seq (Not Equal)',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'patternNotEquals',
+      },
+      value: {
+        label: 'Seq',
+        fieldType: 'string',
+        defaultValue: () => '',
+      },
+    },
+    supportedFor: isStringValueType,
+  },
+  isNA: {
+    label: 'Is NA',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'isNA',
+      },
+    },
+    supportedFor: () => true,
+  },
+  isNotNA: {
+    label: 'Is Not NA',
+    form: {
+      column: {
+        label: 'Column',
+        fieldType: 'SUniversalPColumnId',
+        defaultValue: () => undefined,
+      },
+      type: {
+        label: 'Predicate',
+        fieldType: 'FilterType',
+        defaultValue: () => 'isNotNA',
+      },
+    },
+    supportedFor: () => true,
+  },
+  or: {
+    label: 'Or',
+    form: {
+      type: {
+        fieldType: 'FilterType',
+        label: 'Predicate',
+        defaultValue: () => 'or',
+      },
+      filters: {
+        fieldType: 'unknown[]',
+        label: 'Filters',
+        defaultValue: () => [],
+      },
+    },
+    supportedFor: () => false,
+  },
+  and: {
+    label: 'And',
+    form: {
+      type: {
+        fieldType: 'FilterType',
+        label: 'Predicate',
+        defaultValue: () => 'and',
+      },
+      filters: {
+        fieldType: 'unknown[]',
+        label: 'Filters',
+        defaultValue: () => [],
+      },
+    },
+    supportedFor: () => false,
+  },
+  not: {
+    label: 'Not',
+    form: {
+      type: {
+        fieldType: 'FilterType',
+        label: 'Predicate',
+        defaultValue: () => 'not',
+      },
+      filter: {
+        fieldType: 'form',
+        label: 'Filter',
+        defaultValue: () => undefined,
+      },
+    },
+    supportedFor: () => false,
+  },
+} satisfies FilterSpecMetadataRecord<FilterSpecType>;
+
+export function getFilterUiTypeOptions(columnSpec?: SimplifiedPColumnSpec) {
+  if (!columnSpec) {
+    return [];
+  }
+
+  return Object.entries(filterUiMetadata).filter(([_, metadata]) => metadata.supportedFor(columnSpec)).map(([type, metadata]) => ({
+    label: metadata.label,
+    value: type,
+  }));
+}
+
+export function getFilterUiMetadata(type: FilterSpecType) {
+  return filterUiMetadata[type];
+}
+
+function isNumericValueType(spec: SimplifiedPColumnSpec): boolean {
+  return spec.valueType === 'Int' || spec.valueType === 'Long' || spec.valueType === 'Float' || spec.valueType === 'Double';
+}
+
+function isStringValueType(spec: SimplifiedPColumnSpec): boolean {
+  return spec.valueType === 'String';
+}

package/src/composition/filters/types.ts

@@ -0,0 +1,44 @@
+import type { FilterSpec, FilterSpecOfType, FilterSpecType, SimplifiedPColumnSpec, SUniversalPColumnId } from '@platforma-sdk/model';
+
+/** Metadata about a single field in FilterSpec */
+export type FilterSpecTypeField<V> = {
+  label: string;
+  fieldType: FilterSpecTypeToLiteral<V>;
+  defaultValue: () => V | undefined;
+};
+
+/** Converts each field in FilterSpec to FilterSpecTypeField */
+export type FilterSpecTypeFieldRecord<T extends FilterSpec> = { [K in keyof T]: FilterSpecTypeField<T[K]>; };
+
+/** Extracts FilterSpecOfType from FilterSpecType */
+export type FilterSpecFormField<T extends FilterSpec> = {
+  [K in keyof T]: FilterSpecTypeField<T[K]>
+};
+
+/** Metadata about all supported filter types */
+export type FilterSpecMetadataRecord<T extends FilterSpecType> = {
+  [P in T]: {
+    label: string;
+    labelNot?: string;
+    form: FilterSpecFormField<FilterSpecOfType<P>>;
+    supportedFor: (spec1: SimplifiedPColumnSpec, spec2: SimplifiedPColumnSpec | undefined) => boolean;
+  }
+};
+
+/** Converts FilterSpecType to a literal string representing the type */
+export type FilterSpecTypeToLiteral<T> =
+    [T] extends [FilterSpecType] ? 'FilterType' :
+        [T] extends [SUniversalPColumnId] ? 'SUniversalPColumnId' :
+            [T] extends [number] ? 'number' :
+                [T] extends [number | undefined] ? 'number?' :
+                    [T] extends [string] ? 'string' :
+                        [T] extends [string | undefined] ? 'string?' :
+                            [T] extends [boolean] ? 'boolean' :
+                                [T] extends [boolean | undefined] ? 'boolean?' :
+                                    [T] extends [unknown[]] ? 'unknown[]' :
+                                    // this is special
+                                      T extends number ? 'number' :
+                                        T extends string ? 'string' :
+                                          T extends boolean ? 'boolean' :
+                                            T extends Record<string, unknown> ? 'form' :
+                                              'unknown';

package/src/index.ts

@@ -114,9 +114,10 @@ export { useSortable } from './composition/useSortable';
 export { useSortable2 } from './composition/useSortable2';
 export { useTheme } from './composition/useTheme';
 
+export * from './composition/computedCached';
+export * from './composition/filters';
 export * from './composition/useWatchFetch';
 export * from './composition/watchCached';
-export * from './composition/computedCached';
 
 /**
  * Utils/Partials

package/dist/generated/components/svg/images/SvgRequired.vue.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export default _default;

package/dist/generated/components/svg/images/SvgRequired.vue.js

@@ -1,17 +0,0 @@
-(function(){"use strict";try{if(typeof document<"u"){var e=document.createElement("style");e.appendChild(document.createTextNode(".SvgRequired{background-image:url(data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%225%22%20height%3D%2212%22%20viewBox%3D%220%200%205%2012%22%20fill%3D%22none%22%3E%3Cpath%20d%3D%22M1.51685%204.8L2.5%203.34159L3.47612%204.8L4.39607%204.12743L3.31461%202.7469L5%202.25133L4.64888%201.16106L3.00562%201.77699L3.06882%200H1.93118L1.99438%201.77699L0.351124%201.16106L0%202.25133L1.68539%202.7469L0.59691%204.12743L1.51685%204.8Z%22%20fill%3D%22%23F1222F%22%2F%3E%3C%2Fsvg%3E)}")),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
-import e from "./SvgRequired.vue3.js";
-import { createElementBlock as t, openBlock as o } from "vue";
-
-import r from "../../../../_virtual/_plugin-vue_export-helper.js";
-const c = {
-  class: "svg-icon SvgRequired",
-  style: { width: "5px", height: "12px" }
-};
-function i(s, p, n, _, d, m) {
-  return o(), t("div", c);
-}
-const h = /* @__PURE__ */ r(e, [["render", i]]);
-export {
-  h as default
-};
-//# sourceMappingURL=SvgRequired.vue.js.map

package/dist/generated/components/svg/images/SvgRequired.vue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvgRequired.vue.js","sources":["../../../../../src/generated/components/svg/images/SvgRequired.vue"],"sourcesContent":["<!-- ⚠️ AUTOGENERATED. DO NOT EDIT. -->\n<script lang=\"ts\">\nimport '../svg-styles.css';\nexport default { name: 'SvgRequired' };\n</script>\n\n<template>\n  <div class=\"svg-icon SvgRequired\" style=\"width: 5px; height: 12px\" />\n</template>\n\n<style>\n  .SvgRequired { background-image: url(\"data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%225%22%20height%3D%2212%22%20viewBox%3D%220%200%205%2012%22%20fill%3D%22none%22%3E%3Cpath%20d%3D%22M1.51685%204.8L2.5%203.34159L3.47612%204.8L4.39607%204.12743L3.31461%202.7469L5%202.25133L4.64888%201.16106L3.00562%201.77699L3.06882%200H1.93118L1.99438%201.77699L0.351124%201.16106L0%202.25133L1.68539%202.7469L0.59691%204.12743L1.51685%204.8Z%22%20fill%3D%22%23F1222F%22%2F%3E%3C%2Fsvg%3E\"); }\n</style>\n"],"names":["_hoisted_1"],"mappings":";;;;AAOoC,MAAAA,IAAA;AAAA,EAAA,OAAA;AAAA;;;;;;"}

package/dist/generated/components/svg/images/SvgRequired.vue3.js

@@ -1,6 +0,0 @@
-
-const a = { name: "SvgRequired" };
-export {
-  a as default
-};
-//# sourceMappingURL=SvgRequired.vue3.js.map

package/dist/generated/components/svg/images/SvgRequired.vue3.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvgRequired.vue3.js","sources":["../../../../../src/generated/components/svg/images/SvgRequired.vue"],"sourcesContent":["<!-- ⚠️ AUTOGENERATED. DO NOT EDIT. -->\n<script lang=\"ts\">\nimport '../svg-styles.css';\nexport default { name: 'SvgRequired' };\n</script>\n\n<template>\n  <div class=\"svg-icon SvgRequired\" style=\"width: 5px; height: 12px\" />\n</template>\n\n<style>\n  .SvgRequired { background-image: url(\"data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%225%22%20height%3D%2212%22%20viewBox%3D%220%200%205%2012%22%20fill%3D%22none%22%3E%3Cpath%20d%3D%22M1.51685%204.8L2.5%203.34159L3.47612%204.8L4.39607%204.12743L3.31461%202.7469L5%202.25133L4.64888%201.16106L3.00562%201.77699L3.06882%200H1.93118L1.99438%201.77699L0.351124%201.16106L0%202.25133L1.68539%202.7469L0.59691%204.12743L1.51685%204.8Z%22%20fill%3D%22%23F1222F%22%2F%3E%3C%2Fsvg%3E\"); }\n</style>\n"],"names":["_sfc_main"],"mappings":";AAGA,MAAAA,IAAe,EAAE,MAAM,cAAA;"}