@zenify-omni/chat-ui-react-js 0.1.0

package/store/crm-organization-list-filter-store.js

@@ -0,0 +1,126 @@
+import { create } from "./index.js";
+import { devtools } from "./devtools.js";
+import { DEFAULT_TABLE_COLUMNS } from "@zenify-omni/chat-js/constants/crm-organization.js";
+import { getAvailableSourceTabs } from "@zenify-omni/chat-js/utils/crm-organization.js";
+const defaultOrganizationColumnSelected = DEFAULT_TABLE_COLUMNS;
+const defaultOrganizationSource = getAvailableSourceTabs()?.[0]?.value;
+const useCrmOrganizationListFilterStore = create(
+  devtools(
+    (set) => ({
+      // Pagination
+      page: 1,
+      pageSize: 10,
+      rowSelection: {},
+      // Side filter (source: 'all' | 'dept' | 'mine')
+      source: defaultOrganizationSource,
+      sideFilterTotal: 0,
+      // Search
+      searchText: "",
+      // Sort
+      sortBy: "created_at:desc",
+      // Columns
+      selectedColumnKeys: defaultOrganizationColumnSelected,
+      // Smart view (full object instead of just id, exclusive with conditions/source)
+      selectedSmartView: null,
+      // Saved filter (mutually exclusive with smart view)
+      selectedFilter: null,
+      // Advanced filter UI state
+      filterModel: {
+        fieldRelation: { between: "and", inner: "and" },
+        fieldRule: {}
+      },
+      // BE payload (computed/applied conditions)
+      conditions: null,
+      mainAndOr: "and",
+      subAndOr: "and",
+      // Counts
+      totalQueriedCount: null,
+      // Actions
+      setPage: (page) => set({ page }),
+      setPageSize: (pageSize) => set({ pageSize, page: 1 }),
+      setRowSelection: (updater) => set((state) => ({
+        rowSelection: typeof updater === "function" ? updater(state.rowSelection) : updater
+      })),
+      clearSelection: () => set({ rowSelection: {} }),
+      setSource: (source) => set((state) => {
+        const next = { source, page: 1 };
+        if (state.selectedSmartView !== null) {
+          next.selectedSmartView = null;
+          next.filterModel = {
+            fieldRelation: { between: "and", inner: "and" },
+            fieldRule: {}
+          };
+          next.conditions = null;
+          next.mainAndOr = "and";
+          next.subAndOr = "and";
+        }
+        return next;
+      }),
+      setSearchText: (searchText) => set({ searchText, page: 1 }),
+      setSort: (sortBy) => set({ sortBy, page: 1 }),
+      setSelectedColumnKeys: (selectedColumnKeys) => set({ selectedColumnKeys }),
+      setSelectedSmartView: (selectedSmartView) => set(() => ({
+        selectedSmartView,
+        selectedFilter: null,
+        source: null,
+        selectedColumnKeys: selectedSmartView?.columns?.length ? selectedSmartView.columns : defaultOrganizationColumnSelected,
+        // Đổi smart view: áp sort_by của smart view (hoặc default)
+        // để giữ hành vi hiện tại — Org đọc thẳng `sortBy` từ store.
+        sortBy: selectedSmartView?.sort_by || "created_at:desc",
+        page: 1
+      })),
+      setSelectedFilter: (selectedFilter) => set((state) => ({
+        selectedFilter,
+        selectedSmartView: null,
+        source: !state.source ? defaultOrganizationSource : state.source,
+        conditions: null,
+        mainAndOr: "and",
+        subAndOr: "and"
+      })),
+      setFilterModel: (filterModel) => set({ filterModel }),
+      resetFilterModel: () => set({
+        filterModel: {
+          fieldRelation: { between: "and", inner: "and" },
+          fieldRule: {}
+        }
+      }),
+      setConditions: ({ conditions, mainAndOr, subAndOr }) => set({
+        conditions,
+        mainAndOr: mainAndOr || "and",
+        subAndOr: subAndOr || "and",
+        page: 1
+      }),
+      resetConditions: () => set({ conditions: null, mainAndOr: "and", subAndOr: "and" }),
+      setTotalQueriedCount: (totalQueriedCount) => set({ totalQueriedCount }),
+      setSideFilterTotal: (sideFilterTotal) => set({ sideFilterTotal }),
+      reset: () => set({
+        page: 1,
+        pageSize: 10,
+        rowSelection: {},
+        source: defaultOrganizationSource,
+        sideFilterTotal: 0,
+        searchText: "",
+        sortBy: "created_at:desc",
+        selectedColumnKeys: defaultOrganizationColumnSelected,
+        selectedSmartView: null,
+        selectedFilter: null,
+        filterModel: {
+          fieldRelation: { between: "and", inner: "and" },
+          fieldRule: {}
+        },
+        conditions: null,
+        mainAndOr: "and",
+        subAndOr: "and",
+        totalQueriedCount: null
+      })
+    }),
+    {
+      name: "crm-organization-list-filter-store"
+    }
+  )
+);
+export {
+  defaultOrganizationColumnSelected,
+  defaultOrganizationSource,
+  useCrmOrganizationListFilterStore
+};

package/store/customer-list-filter-store.js

@@ -0,0 +1,139 @@
+import { create } from "./index.js";
+import { devtools } from "./devtools.js";
+import {
+  isAdmin,
+  isRoleAgent,
+  isRoleTeamLeader,
+  isSupervisor
+} from "@zenify-omni/chat-js/utils/auth.js";
+import { CustomerAssign } from "@zenify-omni/chat-js/constants/user.js";
+import {
+  getListPaginationState,
+  subscribeListPagination
+} from "./list-pagination-state.js";
+const pagination = getListPaginationState("customer", { page: 1, pageSize: 10 });
+const getInitialAssign = () => {
+  if (isRoleTeamLeader()) return CustomerAssign.MyGroup;
+  if (isRoleAgent() || isAdmin() || isSupervisor()) return CustomerAssign.ALL;
+  return null;
+};
+const defaultFilterModel = {
+  fieldRelation: {
+    between: "and",
+    inner: "and"
+  },
+  fieldRule: {}
+};
+const defaultCustomerColumnSelected = [
+  "name",
+  "phone",
+  "email",
+  "dob",
+  "source",
+  "organization",
+  "group",
+  "city",
+  "created_at"
+];
+const useCustomerListFilterStore = create(
+  devtools(
+    (set) => ({
+      assign: getInitialAssign(),
+      searchText: "",
+      page: pagination.page,
+      pageSize: pagination.pageSize,
+      filterModel: defaultFilterModel,
+      refreshField: /* @__PURE__ */ new Date(),
+      selectedFilter: null,
+      selectedColumnKeys: defaultCustomerColumnSelected,
+      targetClick: null,
+      // Quick filter (sidebar "Lọc nhanh") snapshot — kept in sync with the
+      // entity-agnostic useFilterStore, mirrors lead-list-filter-store.
+      quickFilter: {
+        filters: [],
+        conditionRelation: "and"
+      },
+      updateQuickFilter: (quickFilter) => set({ quickFilter }),
+      totalQueriedCount: 0,
+      // Map of assign-value -> count, one entry per side-filter tab.
+      sideFilterTotal: {},
+      selectedRowKeys: {},
+      // Unified conditions sent to BE (mirror lead pattern)
+      conditions: null,
+      mainAndOr: "and",
+      subAndOr: "and",
+      setConditions: ({ conditions, mainAndOr, subAndOr }) => set({
+        conditions,
+        mainAndOr: mainAndOr || "and",
+        subAndOr: subAndOr || "and",
+        page: 1
+      }),
+      resetConditions: () => set({ conditions: null, mainAndOr: "and", subAndOr: "and" }),
+      // Smart View
+      selectedSmartView: null,
+      setSelectedSmartView: (selectedSmartView) => set({
+        selectedSmartView,
+        selectedColumnKeys: selectedSmartView?.columns?.length ? selectedSmartView.columns : defaultCustomerColumnSelected,
+        // Reset sort explicit để smart-view sort áp dụng.
+        sortBy: null
+      }),
+      // Sort explicit do user click vào header. Null = rơi về smart-view/default.
+      sortBy: null,
+      setSort: (sortBy, { resetPage = true } = {}) => set(resetPage ? { sortBy, page: 1 } : { sortBy }),
+      setRefreshField: (date) => set({ refreshField: date }),
+      setAssign: (assign) => set({ assign, page: 1 }),
+      setSearchText: (searchText) => {
+        set({ searchText, page: 1 });
+      },
+      setPage: (page) => set({ page }),
+      setPageSize: (pageSize) => set({ pageSize }),
+      setTotalQueriedCount: (count) => set({ totalQueriedCount: count }),
+      setSideFilterTotal: (counts) => set({ sideFilterTotal: counts }),
+      setSelectedRowKeys: (rowKey) => set({ selectedRowKeys: rowKey }),
+      setFilterModel: ({ fieldRelation, fieldRule } = {}) => {
+        const validFieldRelation = fieldRelation || defaultFilterModel.fieldRelation;
+        const validFieldRule = fieldRule || defaultFilterModel.fieldRule;
+        set({
+          filterModel: {
+            fieldRelation: validFieldRelation,
+            fieldRule: validFieldRule
+          }
+        });
+      },
+      setSelectedFilter: (selectedFilter) => set({
+        selectedFilter,
+        conditions: null,
+        mainAndOr: "and",
+        subAndOr: "and",
+        sortBy: null
+      }),
+      setSelectedColumnKeys: (selectedColumnKeys) => set({ selectedColumnKeys }),
+      setTargetClick: (targetClick) => set({ targetClick }),
+      resetFilterModel: () => set({ filterModel: { ...defaultFilterModel } }),
+      setDefaults: () => {
+        set({
+          assign: getInitialAssign(),
+          searchText: "",
+          filterModel: { ...defaultFilterModel },
+          targetClick: null,
+          selectedFilter: null,
+          conditions: null,
+          mainAndOr: "and",
+          subAndOr: "and",
+          selectedSmartView: null,
+          sortBy: null
+        });
+      }
+    }),
+    {
+      name: "customer-list-filter-store"
+    }
+  )
+);
+subscribeListPagination(useCustomerListFilterStore, "customer");
+export {
+  defaultCustomerColumnSelected,
+  defaultFilterModel,
+  getInitialAssign,
+  useCustomerListFilterStore
+};

package/store/devtools.js

@@ -0,0 +1,9 @@
+import { devtools as zustandDevtools } from "zustand/middleware";
+import { env } from "../config/env.js";
+const devtools = (stateCreator, options) => zustandDevtools(stateCreator, {
+  ...options,
+  enabled: env.DEV
+});
+export {
+  devtools
+};

package/store/duplicate-phone-warning-store.js

@@ -0,0 +1,18 @@
+import { create } from "./index.js";
+import { devtools } from "./devtools.js";
+const useDuplicatePhoneWarningStore = create(
+  devtools(
+    (set) => ({
+      isOpen: false,
+      contactId: null,
+      warning: null,
+      open: (contactId, warning) => set({ isOpen: true, contactId, warning }),
+      close: () => set({ isOpen: false, contactId: null, warning: null })
+    }),
+    { name: "duplicate-phone-warning-store" }
+  )
+);
+var duplicate_phone_warning_store_default = useDuplicatePhoneWarningStore;
+export {
+  duplicate_phone_warning_store_default as default
+};

package/store/entity-extract-store.js

@@ -0,0 +1,72 @@
+import i18n from "@zenify-omni/chat-js/lib/i18n/index.js";
+import { create } from "./index.js";
+import { devtools } from "zustand/middleware";
+import { EntityExtractSocketType } from "@zenify-omni/chat-js/constants/chatbot.js";
+const entityExtractRunKey = (botId, sourceLink, refId = null) => botId && sourceLink ? `${botId}:${sourceLink}:${refId ?? "null"}` : null;
+const useEntityExtractStore = create(
+  devtools(
+    (set) => ({
+      byRun: {},
+      // payload socket: { type, bot_id, user_id, data }
+      ingestEvent: ({ type, bot_id: botId, data }) => {
+        const key = entityExtractRunKey(
+          botId,
+          data?.source_link,
+          data?.ref_id ?? null
+        );
+        if (!type || !key) return;
+        set((state) => {
+          const prev = state.byRun[key] || {};
+          const next = {
+            ...prev,
+            lastType: type,
+            brandId: data?.brand_id ?? prev.brandId,
+            sourceLink: data?.source_link ?? prev.sourceLink,
+            refId: data?.ref_id ?? prev.refId ?? null
+          };
+          if (type === EntityExtractSocketType.PROGRESS) {
+            next.process = {
+              percent: data?.percent ?? 0,
+              steps: data?.steps || []
+            };
+            next.error = null;
+          } else if (type === EntityExtractSocketType.COMPLETED) {
+            next.process = {
+              percent: 100,
+              steps: (prev.process?.steps || []).map((step) => ({
+                ...step,
+                status: "completed"
+              }))
+            };
+            next.counts = data?.counts || {};
+            next.error = null;
+          } else if (type === EntityExtractSocketType.FAILED) {
+            next.error = data?.error || {
+              message: i18n.t("lumi:message.entityExtractFailed", {
+                defaultValue: "B\xF3c t\xE1ch d\u1EEF li\u1EC7u th\u1EA5t b\u1EA1i"
+              })
+            };
+          }
+          return { byRun: { ...state.byRun, [key]: next } };
+        });
+      },
+      // Reset 1 run (trigger lại / reject / đã duyệt xong)
+      clearRun: (key) => {
+        if (!key) return;
+        set((state) => {
+          if (!state.byRun[key]) return state;
+          const byRun = { ...state.byRun };
+          delete byRun[key];
+          return { byRun };
+        });
+      },
+      clearAll: () => set({ byRun: {} })
+    }),
+    { name: "entity-extract-store" }
+  )
+);
+var entity_extract_store_default = useEntityExtractStore;
+export {
+  entity_extract_store_default as default,
+  entityExtractRunKey
+};

package/store/file-preview-store.js

@@ -0,0 +1,27 @@
+import { create } from "./index.js";
+import { devtools } from "./devtools.js";
+const useFilePreviewStore = create(
+  devtools(
+    (set, get) => ({
+      isOpen: false,
+      files: [],
+      currentIndex: 0,
+      openPreview: (files, index = 0) => set({ isOpen: true, files, currentIndex: index }),
+      closePreview: () => set({ isOpen: false, files: [], currentIndex: 0 }),
+      goNext: () => {
+        const { currentIndex, files } = get();
+        if (currentIndex < files.length - 1)
+          set({ currentIndex: currentIndex + 1 });
+      },
+      goPrev: () => {
+        const { currentIndex } = get();
+        if (currentIndex > 0) set({ currentIndex: currentIndex - 1 });
+      }
+    }),
+    { name: "file-preview-store" }
+  )
+);
+var file_preview_store_default = useFilePreviewStore;
+export {
+  file_preview_store_default as default
+};

package/store/filter-store.js

@@ -0,0 +1,289 @@
+import { create } from "./index.js";
+import { devtools } from "./devtools.js";
+import { v4 as uuid } from "uuid";
+import {
+  QuickFilterOperator,
+  QuickFilterOperatorControl
+} from "@zenify-omni/chat-js/constants/quick-filter.js";
+const isSkipValue = (operator) => [
+  QuickFilterOperator.Exist,
+  QuickFilterOperator.NotExist,
+  QuickFilterOperator.Today,
+  QuickFilterOperator.ThisWeek,
+  QuickFilterOperator.ThisMonth
+].includes(operator);
+const initialAdvancedFilterState = {
+  fieldRelation: {
+    between: "and",
+    inner: "and"
+  },
+  fieldRule: {},
+  options: [],
+  selectedOptionKeys: []
+};
+const initialQuickFilterState = {
+  filters: [],
+  conditionRelation: "and",
+  lastReloadTime: Date.now()
+};
+const DEFAULT_QUICK_FILTER_FIELD_KEYS = [
+  "status",
+  "source_detail",
+  "assign_agent_id",
+  "is_sla_violated",
+  "created_at"
+];
+const buildDefaultQuickFilters = (filterFieldOptions, fieldKeys) => fieldKeys.map((key) => {
+  const field = (filterFieldOptions ?? []).find(
+    (option) => option.key === key
+  );
+  if (!field) return null;
+  const defaultOperator = field.meta_data.operators?.[0]?.value ?? "";
+  return {
+    id: uuid(),
+    dirty: false,
+    field,
+    operator: defaultOperator,
+    value: ""
+  };
+}).filter(Boolean);
+const useFilterStore = create(
+  devtools(
+    (set, get) => ({
+      // Advanced Filter State
+      ...initialAdvancedFilterState,
+      // Quick Filter State
+      ...initialQuickFilterState,
+      // Advanced Filter Actions
+      setFieldRelation: (fieldRelation) => set((state) => ({
+        fieldRelation: { ...state.fieldRelation, ...fieldRelation }
+      })),
+      setFieldRule: (fieldRule) => set({ fieldRule }),
+      setOptions: (options) => set({ options }),
+      setSelectedOptionKeys: (selectedOptionKeys) => set({ selectedOptionKeys }),
+      toggleOption: (option) => set((state) => {
+        const newFieldRule = { ...state.fieldRule };
+        let newSelectedOptionKeys = [...state.selectedOptionKeys];
+        if (!newFieldRule[option.key]) {
+          newFieldRule[option.key] = [
+            {
+              ruleId: uuid(),
+              operator: "",
+              value: ""
+            }
+          ];
+          newSelectedOptionKeys.push(option.key);
+        } else {
+          delete newFieldRule[option.key];
+          newSelectedOptionKeys = newSelectedOptionKeys.filter(
+            (key) => key !== option.key
+          );
+        }
+        return {
+          fieldRule: newFieldRule,
+          selectedOptionKeys: newSelectedOptionKeys
+        };
+      }),
+      addRule: (option) => set((state) => {
+        const newFieldRule = { ...state.fieldRule };
+        const optionKey = option.key;
+        newFieldRule[optionKey] = newFieldRule[optionKey] ?? [];
+        newFieldRule[optionKey].push({
+          ruleId: uuid(),
+          operator: "",
+          value: ""
+        });
+        return { fieldRule: newFieldRule };
+      }),
+      removeRule: (optionKey, ruleId) => set((state) => {
+        const newFieldRule = { ...state.fieldRule };
+        const rules = newFieldRule[optionKey];
+        let newSelectedOptionKeys = [...state.selectedOptionKeys];
+        if (rules.length > 1) {
+          const ruleIndex = rules.findIndex((r) => r.ruleId === ruleId);
+          rules.splice(ruleIndex, 1);
+        } else {
+          delete newFieldRule[optionKey];
+          newSelectedOptionKeys = newSelectedOptionKeys.filter(
+            (key) => key !== optionKey
+          );
+        }
+        return {
+          fieldRule: newFieldRule,
+          selectedOptionKeys: newSelectedOptionKeys
+        };
+      }),
+      changeOperator: (operator, optionKey, ruleId) => set((state) => {
+        const newFieldRule = { ...state.fieldRule };
+        const rules = newFieldRule[optionKey];
+        const ruleIndex = rules.findIndex((r) => r.ruleId === ruleId);
+        rules[ruleIndex].operator = operator;
+        rules[ruleIndex].value = "";
+        return { fieldRule: newFieldRule };
+      }),
+      changeValue: (value, option, ruleId) => set((state) => {
+        const newFieldRule = { ...state.fieldRule };
+        const rules = state.fieldRule[option.key];
+        const ruleIndex = rules.findIndex((r) => r.ruleId === ruleId);
+        rules[ruleIndex].value = value;
+        return { fieldRule: newFieldRule };
+      }),
+      changeRelation: (relationKey, relation) => set((state) => ({
+        fieldRelation: { ...state.fieldRelation, [relationKey]: relation }
+      })),
+      // Quick Filter Actions
+      setQuickFilters: (filters) => set({ filters }),
+      setConditionRelation: (conditionRelation) => set((state) => {
+        const isAllFieldDirty = state.filters.every(
+          (x) => isSkipValue(x.operator) ? true : x.dirty
+        );
+        return {
+          conditionRelation,
+          ...state.filters.length > 0 && isAllFieldDirty && {
+            lastReloadTime: Date.now()
+          }
+        };
+      }),
+      updateQuickFilter: (filterId, updateInfo) => set((state) => {
+        const newFilters = state.filters.map((filter) => {
+          if (filter.id !== filterId) {
+            return filter;
+          }
+          return {
+            ...filter,
+            ...updateInfo
+          };
+        });
+        const oldFiltersObject = state.filters.map((filter) => ({
+          key: filter.field?.key ?? "",
+          operator: filter.operator ?? "",
+          value: filter.value ?? "",
+          dirty: filter.dirty ?? false
+        }));
+        const newFiltersObject = newFilters.map((filter) => ({
+          key: filter.field?.key ?? "",
+          operator: filter.operator ?? "",
+          value: filter.value ?? "",
+          dirty: filter.dirty
+        }));
+        const isFiltersChange = JSON.stringify(oldFiltersObject) !== JSON.stringify(newFiltersObject);
+        const isAllFieldDirty = newFilters.every((filter) => {
+          if (isSkipValue(filter.operator)) return true;
+          if (filter.dirty) return true;
+          const oldFilter = state.filters.find((x) => x.id === filter.id);
+          if (isSkipValue(oldFilter.operator) && !isSkipValue(filter.operator)) {
+            return true;
+          }
+          return false;
+        });
+        return {
+          filters: newFilters,
+          ...isFiltersChange && isAllFieldDirty && {
+            lastReloadTime: Date.now()
+          }
+        };
+      }),
+      removeQuickFilter: (filterId) => set((state) => {
+        const newFilters = state.filters.filter((x) => x.id !== filterId);
+        const isAllFieldDirty = newFilters.every(
+          (x) => isSkipValue(x.operator) ? true : x.dirty
+        );
+        const isAllFieldHasValue = newFilters.every((x) => {
+          if (isSkipValue(x.operator)) return true;
+          if (x.operator === QuickFilterOperator.Between) {
+            return !!(x.value?.from && x.value?.to);
+          }
+          return !!x.value;
+        });
+        return {
+          filters: newFilters,
+          ...isAllFieldDirty && isAllFieldHasValue && {
+            lastReloadTime: Date.now()
+          }
+        };
+      }),
+      changeQuickOperator: (filter, operator) => set((state) => {
+        const shouldResetValue = [
+          QuickFilterOperator.Exist,
+          QuickFilterOperator.NotExist,
+          QuickFilterOperator.Today,
+          QuickFilterOperator.ThisWeek,
+          QuickFilterOperator.ThisMonth
+        ].includes(operator);
+        const updateInfo = {
+          operator
+        };
+        if (shouldResetValue) {
+          updateInfo.value = [
+            QuickFilterOperatorControl.MultiText,
+            QuickFilterOperatorControl.MultiSelect,
+            QuickFilterOperatorControl.AsyncSearchMultiSelect
+          ].includes(filter.field?.meta_data?.control) ? [] : "";
+        }
+        const newFilters = state.filters.map(
+          (f) => f.id === filter.id ? { ...f, ...updateInfo } : f
+        );
+        return { filters: newFilters };
+      }),
+      addQuickFilter: () => set((state) => {
+        const newField = {
+          id: uuid(),
+          dirty: false,
+          field: null,
+          operator: null,
+          value: ""
+        };
+        return { filters: [...state.filters, newField] };
+      }),
+      // Xóa lọc nhanh: giữ lại các tiêu chí mặc định (đã chọn field) và chỉ
+      // xóa giá trị đã nhập, thay vì xóa hẳn toàn bộ tiêu chí.
+      removeAllQuickFilters: (filterFieldOptions, fieldKeys = DEFAULT_QUICK_FILTER_FIELD_KEYS) => set({
+        filters: buildDefaultQuickFilters(filterFieldOptions, fieldKeys),
+        conditionRelation: "and",
+        lastReloadTime: Date.now()
+      }),
+      setDefaultQuickFilters: (filterFieldOptions, fieldKeys = DEFAULT_QUICK_FILTER_FIELD_KEYS) => set({
+        filters: buildDefaultQuickFilters(filterFieldOptions, fieldKeys),
+        conditionRelation: "and"
+      }),
+      triggerReload: () => set({ lastReloadTime: Date.now() }),
+      // Reset functions
+      resetAdvancedFilter: () => set(initialAdvancedFilterState),
+      resetQuickFilter: () => set(initialQuickFilterState),
+      resetAllFilters: () => set({ ...initialAdvancedFilterState, ...initialQuickFilterState }),
+      // Helper functions
+      getFilteredQuickFilters: () => {
+        const state = get();
+        return state.filters.filter((filter) => {
+          if (!filter.field) return false;
+          return isSkipValue(filter.operator) ? true : [
+            QuickFilterOperatorControl.MultiText,
+            QuickFilterOperatorControl.MultiSelect,
+            QuickFilterOperatorControl.AsyncSearchMultiSelect
+          ].includes(filter.field?.meta_data?.control) ? (filter.value?.length ?? 0) > 0 : filter.value !== null && filter.value !== void 0 && filter.value !== "";
+        });
+      },
+      getAdvancedFilterModel: () => {
+        const state = get();
+        return {
+          fieldRelation: state.fieldRelation,
+          fieldRule: state.fieldRule
+        };
+      },
+      getQuickFilterModel: () => {
+        const state = get();
+        return {
+          filters: get().getFilteredQuickFilters(),
+          conditionRelation: state.conditionRelation
+        };
+      }
+    }),
+    {
+      name: "filter-store"
+    }
+  )
+);
+export {
+  isSkipValue,
+  useFilterStore
+};