@webitel/ui-datalist 26.8.7 → 26.8.9

package/src/modules/filters/components/table-filters-panel.vue

@@ -79,6 +79,7 @@ import { ApplyPresetAction, SavePresetAction } from '../../filter-presets';
 import { FilterInitParams, IFilter } from '../classes/Filter';
 import { IFiltersManager } from '../classes/FiltersManager';
 import { useFilterConfigsToolkit } from '../composables/useFilterConfigsToolkit';
+import { useSelectedFilters } from '../composables/useSelectedFilters';
 import { AnyFilterConfig } from '../modules/filterConfig/classes/FilterConfig';
 import { FilterOption } from '../modules/filterConfig/enums/FilterOption';
 import StaticFilterField from './config/static-view/static-filter-field.vue';
@@ -197,36 +198,13 @@ https://webitel.atlassian.net/browse/WTEL-7014
 Clear filters button should be active only if filters are defined in the table-filter-panel. Excluding the search filter
 **/
 
-const listSelectedFilters = computed(() => {
-	const allowedKeys = new Set([
-		...props.filterOptions.map((filter) =>
-			typeof filter === 'string' ? filter : filter.name,
-		),
-		...(props.filterableExtensionFields ?? []).map((filter) => filter.id),
-	]);
-	return new Map(
-		[
-			...props.filtersManager.filters,
-		].filter(([key]) => allowedKeys.has(key)),
-	);
+const { listSelectedFilters, hasAnyFilters } = useSelectedFilters({
+	filtersManager: () => props.filtersManager,
+	filterOptions: () => props.filterOptions,
+	filterableExtensionFields: () => props.filterableExtensionFields,
+	filterConfigs,
 });
 
-/**
- * @description
- * Filters applied by the user. `notDeletable` configs are skipped – they are
- * seeded defaults, not a user choice, so they must not block preset restore.
- */
-const hasAnyFilters = computed(() =>
-	[
-		...listSelectedFilters.value.keys(),
-	].some((name) => {
-		const filterConfig = filterConfigs.value.find(
-			(config) => String(config.name) === String(name),
-		);
-		return !filterConfig?.notDeletable;
-	}),
-);
-
 const presetStore = props.usePresetsStore ? props.usePresetsStore() : null;
 
 const handleResetFilters = () => {

package/src/modules/filters/components/types/Filter.types.ts

@@ -18,6 +18,11 @@ export interface StaticFilterEmits extends FilterEmits {
 
 export interface DynamicFilterEmits extends FilterEmits {}
 
+/** column filter lives in a popover, so it also asks the parent to close it */
+export interface ColumnFilterEmits extends StaticFilterEmits {
+	close: [];
+}
+
 export interface FilterProps {
 	filter: IFilter;
 	filterConfig: AnyFilterConfig;

package/src/modules/filters/composables/useColumnFilter.ts

@@ -0,0 +1,116 @@
+import type { DataField } from '@webitel/api-services/gen/models';
+import type { WtTableHeader } from '@webitel/ui-sdk/components/wt-table/types/WtTable';
+import { computed, type MaybeRefOrGetter, toValue } from 'vue';
+import { useI18n } from 'vue-i18n';
+
+import type { FilterName } from '../classes/Filter';
+import type { IFiltersManager } from '../classes/FiltersManager';
+import { createFilterConfig } from '../modules/filterConfig/classes/createFilterConfig';
+import {
+	type AnyFilterConfig,
+	FilterConfig,
+} from '../modules/filterConfig/classes/FilterConfig';
+import { createTypeExtensionFilterConfig } from '../modules/filterConfig/components/_custom';
+import type { FilterConfigDefinition } from '../modules/filterConfig/types/FilterConfigDefinition';
+
+const isResolvedFilterConfig = (
+	filter: WtTableHeader['filter'],
+): filter is AnyFilterConfig => typeof filter === 'object' && filter !== null;
+
+/**
+ * Resolves a table header into its filter config and the filter currently applied in the
+ * filters manager.
+ *
+ * `header.filter` is either a plain name — resolved the same way the panel does
+ * (useFilterConfigsToolkit): a custom (type extension) column is matched by field id in
+ * `filterableExtensionFields`, a pre-configured definition from `filterOptions` (the page's
+ * filtersOptions) is reused as is, everything else is a standard filter option with an i18n
+ * label fallback — or an already-resolved config, used as is. Passing a resolved config from
+ * `headers.ts` skips the `filterOptions`/`filterableExtensionFields` search entirely.
+ *
+ * [WTEL-7727](https://webitel.atlassian.net/browse/WTEL-7727)
+ */
+export const useColumnFilter = ({
+	header,
+	filtersManager,
+	filterOptions = [],
+	filterableExtensionFields = [],
+}: {
+	header: MaybeRefOrGetter<WtTableHeader>;
+	filtersManager: MaybeRefOrGetter<IFiltersManager>;
+	filterOptions?: MaybeRefOrGetter<FilterConfigDefinition[]>;
+	filterableExtensionFields?: MaybeRefOrGetter<DataField[]>;
+}) => {
+	const { t } = useI18n();
+
+	const resolvedFilter = computed(() => {
+		const filter = toValue(header).filter;
+		return isResolvedFilterConfig(filter) ? filter : undefined;
+	});
+
+	const filterName = computed(
+		() => (resolvedFilter.value?.name ?? toValue(header).filter) as FilterName,
+	);
+
+	const extensionField = computed(() =>
+		resolvedFilter.value
+			? undefined
+			: toValue(filterableExtensionFields).find(
+					(field) => field.id === filterName.value,
+				),
+	);
+
+	const configuredOption = computed(() =>
+		resolvedFilter.value
+			? undefined
+			: toValue(filterOptions).find(
+					(opt): opt is AnyFilterConfig =>
+						typeof opt !== 'string' && opt.name === filterName.value,
+				),
+	);
+
+	const filterConfig = computed(() => {
+		let config: AnyFilterConfig;
+
+		if (resolvedFilter.value) {
+			config = resolvedFilter.value;
+		} else if (extensionField.value) {
+			config = createTypeExtensionFilterConfig(
+				{
+					name: extensionField.value.id,
+				},
+				{
+					field: extensionField.value,
+				},
+			);
+		} else {
+			const option = configuredOption.value;
+			config =
+				option instanceof FilterConfig
+					? option
+					: option
+						? new FilterConfig({
+								...option,
+								name: option.name,
+							})
+						: createFilterConfig({
+								name: filterName.value,
+							});
+		}
+
+		if (!config.label) {
+			config.label = t(`webitelUI.filters.${config.name}`);
+		}
+
+		return config;
+	});
+
+	const filter = computed(() =>
+		toValue(filtersManager).getFilter(filterName.value),
+	);
+
+	return {
+		filterConfig,
+		filter,
+	};
+};

package/src/modules/filters/composables/useFilterValueChange.ts

@@ -0,0 +1,58 @@
+import { isEmpty } from '@webitel/ui-sdk/scripts';
+import { type MaybeRefOrGetter, toValue } from 'vue';
+
+import type { FilterValue, IFilter } from '../classes/Filter';
+import type { StaticFilterEmits } from '../components/types/Filter.types';
+import type { AnyFilterConfig } from '../modules/filterConfig';
+
+type StaticFilterEmit = <K extends keyof StaticFilterEmits>(
+	event: K,
+	...args: StaticFilterEmits[K]
+) => void;
+
+/**
+ * Turns a new filter value into the right manager event:
+ * - empty value (except booleans) → `delete:filter` (only if the filter exists)
+ * - no filter yet → `add:filter`
+ * - filter exists → `update:filter`, keeping its label
+ *
+ * Shared by the static filter field and the column filter.
+ *
+ * [WTEL-7727](https://webitel.atlassian.net/browse/WTEL-7727)
+ */
+export const useFilterValueChange = ({
+	filterConfig,
+	filter,
+	emit,
+}: {
+	filterConfig: MaybeRefOrGetter<AnyFilterConfig>;
+	filter: MaybeRefOrGetter<IFilter | undefined>;
+	emit: StaticFilterEmit;
+}) => {
+	const onValueChange = (value: FilterValue) => {
+		const currentFilter = toValue(filter);
+		const config = toValue(filterConfig);
+
+		if (isEmpty(value) && typeof value !== 'boolean') {
+			if (!currentFilter) return;
+			return emit('delete:filter', currentFilter);
+		}
+
+		if (isEmpty(currentFilter?.value)) {
+			return emit('add:filter', {
+				name: config.name,
+				value,
+			});
+		}
+
+		emit('update:filter', {
+			name: config.name,
+			value,
+			label: currentFilter?.label,
+		});
+	};
+
+	return {
+		onValueChange,
+	};
+};

package/src/modules/filters/composables/useFilterValuePreview.ts

@@ -0,0 +1,87 @@
+import { computed, type MaybeRefOrGetter, ref, toValue, watch } from 'vue';
+
+import type { IFilter } from '../classes/Filter';
+import type {
+	AnyFilterConfig,
+	FilterConfigSearchMethodParams,
+} from '../modules/filterConfig/classes/FilterConfig';
+import { FilterOptionToPreviewApiSearchMethodMap } from '../modules/filterConfig/components';
+
+/**
+ * @author @dlohvinov
+ *
+ * @description
+ * Loads the data shown in a filter's hover preview (records behind the stored ids)
+ * once per filter value, in the parent, instead of inside tooltip components —
+ * to avoid api requests spam.
+ *
+ * Shared by the panel chip and the column header icon (WTEL-7727).
+ */
+export const useFilterValuePreview = ({
+	filter,
+	filterConfig,
+}: {
+	filter: MaybeRefOrGetter<IFilter | undefined>;
+	filterConfig: MaybeRefOrGetter<AnyFilterConfig>;
+}) => {
+	const localValue = ref();
+
+	const fillLocalValue = async (currentFilter = toValue(filter)) => {
+		if (!currentFilter) {
+			localValue.value = undefined;
+			return;
+		}
+
+		const filterName = currentFilter.name;
+		const filterValue = currentFilter.value;
+		const config = toValue(filterConfig);
+
+		const valueSearchMethod =
+			'searchRecords' in config
+				? (...params: FilterConfigSearchMethodParams) => {
+						/* arrow fn here preserves filterConfig class "this" */
+						return config.searchRecords(...params);
+					}
+				: FilterOptionToPreviewApiSearchMethodMap[filterName];
+
+		if (valueSearchMethod) {
+			const { items } = await valueSearchMethod(
+				{
+					id: filterValue,
+					// -1 returns all records
+					size: -1,
+				},
+				{
+					filterValue,
+					filterName,
+					filterConfig: config,
+				},
+			);
+			localValue.value = items;
+		} else {
+			localValue.value = filterValue;
+		}
+	};
+
+	watch(
+		() => toValue(filter)?.value,
+		() => {
+			fillLocalValue(toValue(filter));
+		},
+		{
+			immediate: true,
+		},
+	);
+
+	// [https://webitel.atlassian.net/browse/WTEL-6732]
+	// if type filter is boolean and value = false, need display preview
+	const isRenderPreview = computed(
+		() => localValue.value === false || localValue.value,
+	);
+
+	return {
+		localValue,
+		isRenderPreview,
+		fillLocalValue,
+	};
+};

package/src/modules/filters/composables/useSelectedFilters.ts

@@ -0,0 +1,64 @@
+import type { DataField } from '@webitel/api-services/gen/models';
+import {
+	type ComputedRef,
+	computed,
+	type MaybeRefOrGetter,
+	toValue,
+} from 'vue';
+
+import type { FilterName, IFilter } from '../classes/Filter';
+import type { IFiltersManager } from '../classes/FiltersManager';
+import type { BaseFilterConfig } from '../modules/filterConfig/classes/FilterConfig';
+import type { FilterConfigDefinition } from '../modules/filterConfig/types/FilterConfigDefinition';
+
+/**
+ * Filters from the manager that belong to this panel/menu (its filter options + extension fields),
+ * so search filters living in the same manager are ignored.
+ *
+ * `hasAnyFilters` skips `notDeletable` configs — they are seeded defaults, not a user choice
+ * ([WTEL-7014](https://webitel.atlassian.net/browse/WTEL-7014)).
+ */
+export const useSelectedFilters = ({
+	filtersManager,
+	filterOptions,
+	filterableExtensionFields = [],
+	filterConfigs,
+}: {
+	filtersManager: MaybeRefOrGetter<IFiltersManager>;
+	filterOptions: MaybeRefOrGetter<FilterConfigDefinition[]>;
+	filterableExtensionFields?: MaybeRefOrGetter<DataField[] | undefined>;
+	filterConfigs: ComputedRef<BaseFilterConfig[]>;
+}) => {
+	const listSelectedFilters = computed(() => {
+		const allowedKeys = new Set<FilterName>([
+			...toValue(filterOptions).map((filter) =>
+				typeof filter === 'string' ? filter : filter.name,
+			),
+			...(toValue(filterableExtensionFields) ?? [])
+				.map((field) => field.id)
+				.filter((id): id is string => id !== undefined),
+		]);
+
+		return new Map<FilterName, IFilter>(
+			[
+				...toValue(filtersManager).filters,
+			].filter(([key]) => allowedKeys.has(key)),
+		);
+	});
+
+	const hasAnyFilters = computed(() =>
+		[
+			...listSelectedFilters.value.keys(),
+		].some((name) => {
+			const filterConfig = filterConfigs.value.find(
+				(config) => String(config.name) === String(name),
+			);
+			return !filterConfig?.notDeletable;
+		}),
+	);
+
+	return {
+		listSelectedFilters,
+		hasAnyFilters,
+	};
+};

package/src/modules/filters/index.ts

@@ -12,6 +12,8 @@ import {
 	type FiltersManagerConfig,
 	type IFiltersManager,
 } from './classes/FiltersManager';
+import ColumnFilterComponent from './components/column/column-filter.vue';
+import FiltersActionsMenuComponent from './components/filters-actions-menu.vue';
 import DynamicFilterSearchComponent from './components/search-bar/dynamic-filter-search.vue';
 import TableFiltersPanelComponent from './components/table-filters-panel.vue';
 import { FilterOption } from './modules/filterConfig/enums/FilterOption';
@@ -28,9 +30,11 @@ export type {
 	IFiltersManager,
 };
 export {
+	ColumnFilterComponent,
 	createFiltersManager,
 	DynamicFilterSearchComponent,
 	Filter,
 	FilterOption,
+	FiltersActionsMenuComponent,
 	TableFiltersPanelComponent,
 };

package/src/modules/filters/modules/filterConfig/components/_custom/type-extension-filter-value-field.vue

@@ -4,7 +4,7 @@
     v-model:model-value="model"
     :field="props.filterConfig.field"
     :required="false"
-    :v="v$.model"
+    :v="!disableValidation && v$.model"
   >
     <template #[WtTypeExtensionFieldKind.Boolean]="{ defaultProps }">
       <has-option-filter-value-field v-bind="defaultProps" v-model:model-value="booleanModel"/>
@@ -12,7 +12,7 @@
     <template #[WtTypeExtensionFieldKind.Select]="{ defaultProps }">
       <wt-single-select
         v-bind="defaultProps"
-        :v="v$.model"
+        :v="!disableValidation && v$.model"
         :model-value="
           model ??
           [] /* so that component won't break when model is nullish at init */
@@ -26,7 +26,7 @@
     <template #[WtTypeExtensionFieldKind.Multiselect]="{ defaultProps }">
       <wt-multi-select
         v-bind="defaultProps"
-        :v="v$.model"
+        :v="!disableValidation && v$.model"
         :model-value="
           model ??
           [] /* so that component won't break when model is nullish at init */
@@ -39,7 +39,10 @@
       />
     </template>
     <template #[WtTypeExtensionFieldKind.Calendar]>
-      <date-time-options-filter-value-field v-model:model-value="dateTimeModel" />
+      <date-time-options-filter-value-field
+        v-model:model-value="dateTimeModel"
+        :disable-validation="disableValidation"
+      />
     </template>
   </wt-type-extension-value-input>
 </template>
@@ -66,6 +69,7 @@ const model = defineModel<unknown>();
 
 const props = defineProps<{
 	filterConfig: ITypeExtensionFilterConfig;
+	disableValidation?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -116,7 +120,7 @@ const v$ = useVuelidate(
 		$autoDirty: true,
 	},
 );
-v$.value.$touch();
+if (!props?.disableValidation) v$.value.$touch();
 watch(
 	() => v$.value.$invalid,
 	(invalid) => {

package/src/modules/filters/modules/filterConfig/components/_shared/date-time-filter/date-time-filter-value-field.vue

@@ -6,7 +6,7 @@
       class="date-time-filter-value-field__picker"
       show-time
       required
-      :v="v$.from"
+      :v="!disableValidation && v$.from"
       @update:model-value="handleInput('from', $event)"
     />
 
@@ -16,7 +16,7 @@
       class="date-time-filter-value-field__picker"
       show-time
       required
-      :v="v$.to"
+      :v="!disableValidation && v$.to"
       @update:model-value="handleInput('to', $event)"
     />
   </div>
@@ -34,6 +34,10 @@ type ModelValue = {
 	to: number;
 };
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const emit = defineEmits<{
 	'update:invalid': [
 		boolean,
@@ -69,8 +73,7 @@ const v$ = useVuelidate(
 	},
 );
 
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 watch(
 	() => v$.value.$invalid,
 	(invalid) => {

package/src/modules/filters/modules/filterConfig/components/_shared/date-time-filter/date-time-options/date-time-options-filter-value-field.vue

@@ -14,7 +14,7 @@
       :label="t('reusable.from')"
       show-time
       required
-			:v="v$.from"
+			:v="!disableValidation && v$.from"
       @update:model-value="changeAbsoluteValue($event, 'from')"
     />
     <wt-datepicker
@@ -23,7 +23,7 @@
       :label="t('reusable.to')"
       show-time
       required
-			:v="v$.to"
+			:v="!disableValidation && v$.to"
       @update:model-value="changeAbsoluteValue($event, 'to')"
     />
   </div>
@@ -39,6 +39,10 @@ import { endOfToday, startOfToday } from 'date-fns';
 import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const model = defineModel<
 	| RelativeDatetimeValue
 	| {
@@ -115,8 +119,7 @@ const v$ = useVuelidate(
 	},
 );
 
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 watch(
 	() => v$.value.$invalid,
 	(invalid) => {

package/src/modules/filters/modules/filterConfig/components/_shared/durations/duration-filter-value-field.vue

@@ -3,14 +3,14 @@
     <wt-timepicker
       :label="t('reusable.from')"
       :model-value="value.from"
-      :v="vFrom"
+      :v="!disableValidation && vFrom"
       format="hh:mm:ss"
       @update:model-value="handleInput('from', $event)"
     />
     <wt-timepicker
       :label="t('reusable.to')"
       :model-value="value.to"
-      :v="vTo"
+      :v="!disableValidation && vTo"
       format="hh:mm:ss"
       @update:model-value="handleInput('to', $event)"
     />
@@ -22,6 +22,10 @@ import { useVuelidate } from '@vuelidate/core';
 import { computed, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const { t } = useI18n();
 
 type ModelValue = {
@@ -74,8 +78,7 @@ const v$ = useVuelidate<{
 		$autoDirty: true,
 	},
 );
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 const vFrom = computed(() => {
 	const modelValidation = v$.value.model;
 	if (!modelValidation) return undefined;

package/src/modules/filters/modules/filterConfig/components/_shared/string-filter/string-filter-value-field.vue

@@ -2,7 +2,7 @@
   <wt-input-text
     v-model:model-value="model"
     :label="t('webitelUI.filters.filterValue')"
-    :v="v$.model"
+    :v="!disableValidation && v$.model"
   />
 </template>
 
@@ -14,6 +14,10 @@ import { useI18n } from 'vue-i18n';
 
 type ModelValue = string;
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const model = defineModel<ModelValue>();
 if (!model.value) {
 	model.value = '';
@@ -35,8 +39,7 @@ const v$ = useVuelidate(
 	},
 );
 
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 const emit = defineEmits<{
 	'update:invalid': [
 		boolean,

package/src/modules/filters/modules/filterConfig/components/agent/agent-filter-value-field.vue

@@ -3,7 +3,7 @@
     :label="t('webitelUI.filters.filterValue')"
     :search-method="searchMethod"
     :model-value="model"
-    :v="v$.model"
+    :v="!disableValidation && v$.model"
     option-value="id"
     @update:model-value="handleInput"
   />
@@ -20,6 +20,10 @@ import { searchMethod } from './config.js';
 
 type ModelValue = number[];
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const model = defineModel<ModelValue>();
 
 const emit = defineEmits<{
@@ -44,8 +48,7 @@ const v$ = useVuelidate(
 	},
 );
 
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 watch(
 	() => v$.value.$invalid,
 	(invalid) => {

package/src/modules/filters/modules/filterConfig/components/amd-result/amd-result-filter-value-field.vue

@@ -3,7 +3,7 @@
     :label="t('webitelUI.filters.filterValue')"
     :options="AmdResultOptions"
     v-model:model-value="selectValue"
-    :v="v$.model"
+    :v="!disableValidation && v$.model"
     data-key="value"
     option-value="value"
   />
@@ -25,6 +25,10 @@ import { AmdResultOptions } from '../../enums/options/AMDResultOptions';
 
 const AMD_RESULT_EMPTY_VALUE = 'EMPTY';
 
+const props = defineProps<{
+	disableValidation?: boolean;
+}>();
+
 const model = defineModel<string[]>();
 const { t } = useI18n();
 
@@ -64,8 +68,7 @@ const v$ = useVuelidate(
 	},
 );
 
-v$.value.$touch();
-
+if (!props?.disableValidation) v$.value.$touch();
 const emit = defineEmits<{
 	'update:invalid': [
 		boolean,