@milaboratories/uikit 2.4.30 → 2.5.1

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/components/PlAccordion/ExpandTransition.vue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExpandTransition.vue.js","sources":["../../../src/components/PlAccordion/ExpandTransition.vue"],"sourcesContent":["<script lang=\"ts\" setup>\nconst onStart = (el: Element) => {\n  el.classList.add('expand-collapse-fix');\n  (el as HTMLElement).style.setProperty('--component-height', el.scrollHeight + 'px');\n};\n\nconst onAfter = (el: Element) => {\n  (el as HTMLElement).style.removeProperty('--component-height');\n  el.classList.remove('expand-collapse-fix');\n};\n</script>\n\n<template>\n  <Transition name=\"expand-collapse\" @enter=\"onStart\" @leave=\"onStart\" @after-enter=\"onAfter\" @after-leave=\"onAfter\">\n    <slot/>\n  </Transition>\n</template>\n\n<style>\n.expand-collapse-fix {\n  overflow: hidden;\n}\n\n.expand-collapse-enter-active,\n.expand-collapse-leave-active {\n  transition:\n    height 0.2s ease-in-out,\n    opacity 0.2s ease-in-out;\n  height: var(--component-height);\n}\n\n.expand-collapse-enter-from,\n.expand-collapse-leave-to {\n  opacity: 0.5;\n  height: 0;\n}\n</style>\n"],"names":["onStart","el","onAfter"],"mappings":";;;;AACA,UAAMA,IAAU,CAACC,MAAgB;AAC/B,MAAAA,EAAG,UAAU,IAAI,qBAAqB,GACrCA,EAAmB,MAAM,YAAY,sBAAsBA,EAAG,eAAe,IAAI;AAAA,IACpF,GAEMC,IAAU,CAACD,MAAgB;AAC9B,MAAAA,EAAmB,MAAM,eAAe,oBAAoB,GAC7DA,EAAG,UAAU,OAAO,qBAAqB;AAAA,IAC3C;;;;;;;;;;;;;;;"}