@webitel/ui-sdk 25.4.55 → 25.4.56

package/src/modules/Filters/v2/filters/types/Filter.d.ts

@@ -1,46 +0,0 @@
-export type FilterName = string;
-export type FilterLabel = string;
-export type FilterValue =
-  | object
-  | []
-  | string
-  | number
-  | boolean
-  | undefined
-  | null;
-
-/**
- * represents user-input data, that should be (re)stored
- */
-export interface FilterData {
-  value: FilterValue;
-  label?: FilterLabel;
-}
-
-export interface FilterInitParams extends FilterData {
-  name: FilterName;
-}
-
-export interface FilterEnumOption {
-  locale: string;
-  value: FilterValue;
-}
-
-export interface FilterConfig {
-  /**
-   * Perform simple type conversion on store/restore,
-   * without need to provide custom store/restore functions
-   */
-  storableType?: string;
-  /**
-   * list of persistence storages that should be used for this filter
-   */
-  storage?: string[];
-}
-
-export interface IFilter {
-  name: FilterName;
-  value: FilterValue;
-  label?: FilterLabel;
-  set: (data: FilterData) => IFilter;
-}

package/src/modules/Filters/v2/filters/types/FilterSearch.d.ts

@@ -1,10 +0,0 @@
-import { Validation } from '@vuelidate/core';
-
-import { FilterLabel, FilterValue } from './Filter';
-
-export interface FilterSearch {
-  value: FilterValue;
-  text: FilterLabel;
-  hint?: string | undefined;
-  v?: Validation | undefined;
-}

package/src/modules/Filters/v2/filters/types/FiltersManager.d.ts

@@ -1,76 +0,0 @@
-import type {
-  FilterConfig,
-  FilterInitParams,
-  FilterLabel,
-  FilterName,
-  FilterValue,
-  IFilter,
-} from './Filter.types.ts';
-
-export interface IFiltersManager {
-  filters: Map<FilterName, IFilter>;
-
-  hasFilter: (name: FilterName) => boolean;
-  getFilter: (name: FilterName) => IFilter;
-  addFilter: (
-    params: FilterInitParams,
-    payload?: object,
-    config?: FilterConfig,
-  ) => IFilter;
-  updateFilter: ({
-    name,
-  }: {
-    name: FilterName;
-    value?: FilterValue;
-    label?: FilterLabel;
-  }) => IFilter;
-  deleteFilter: (name: FilterName) => IFilter;
-
-  /**
-   * Converts filters data to String, that can be stored
-   */
-  toString: () => string;
-
-  /**
-   * Restores filters from string
-   */
-  fromString: (snapshotStr: string) => void;
-
-  /**
-   * deletes filters
-   * If include/exclude are not provided, all filters will be deleted
-   */
-  reset: ({
-    include,
-    exclude,
-  }?: {
-    include?: FilterName[];
-    exclude?: FilterName[];
-  }) => void;
-
-  /**
-   * @returns Array<FilterName>
-   */
-  getAllKeys: () => FilterName[];
-
-  /**
-   * @returns { FilterName: FilterValue }
-   */
-
-  getAllValues: () => { [name: FilterName]: FilterValue };
-  /**
-   * @returns Array<IFilter>
-   * @param include
-   * @param exclude
-   */
-
-  getFiltersList: ({
-    include,
-    exclude,
-  }?: {
-    include?: FilterName[];
-    exclude?: FilterName[];
-  }) => IFilter[];
-}
-
-export type FiltersManagerConfig = FilterConfig;

package/src/modules/Filters/v2/headers/createTableHeadersStore.ts

@@ -1,140 +0,0 @@
-import { defineStore } from 'pinia';
-import { computed, ref } from 'vue';
-
-import { WtTableHeader } from '../../../../components/wt-table/types/WtTable';
-import { sortToQueryAdapter } from '../../../../scripts';
-import { SortSymbols } from '../../../../scripts/sortQueryAdapters';
-import { PersistedStorageType } from '../persist/PersistedStorage.types';
-import { usePersistedStorage } from '../persist/usePersistedStorage.ts';
-
-export const createTableHeadersStore = (
-  namespace: string,
-  { headers: rawHeaders },
-) => {
-  const id = `${namespace}/headers`;
-
-  return defineStore(id, () => {
-    const headers = ref(rawHeaders);
-
-    const shownHeaders = computed(() => {
-      return headers.value.filter((header) => header.show);
-    });
-
-    const fields = computed(() => {
-      return shownHeaders.value.map((header) => header.field);
-    });
-
-    const sort = computed(() => {
-      const encodeSortQuery = ({ column, order }) =>
-        `${sortToQueryAdapter(order)}${column.field}`;
-
-      const sortedCol = headers.value.find((header) => header.sort);
-
-      return sortedCol
-        ? encodeSortQuery({ column: sortedCol, order: sortedCol.sort })
-        : null;
-    });
-
-    const $reset = () => {
-      headers.value = rawHeaders;
-    };
-
-    const updateShownHeaders = (value) => {
-      headers.value = value;
-    };
-
-    const updateFields = (fields: string[]) => {
-      const newHeaders = headers.value.map((header: WtTableHeader) => {
-        return {
-          ...header,
-          show: fields.includes(header.field),
-        };
-      });
-      updateShownHeaders(newHeaders);
-    };
-
-    const updateSort = (column) => {
-      const getNextSortOrder = (sort) => {
-        switch (sort) {
-          case SortSymbols.NONE:
-            return SortSymbols.ASC;
-          case SortSymbols.ASC:
-            return SortSymbols.DESC;
-          case SortSymbols.DESC:
-            return SortSymbols.NONE;
-          default:
-            return SortSymbols.ASC;
-        }
-      };
-
-      const changeHeadersSort = ({ headers, sortedHeader, order }) => {
-        return headers.map((header) => {
-          if (header.sort === undefined) return header;
-
-          // reset all headers by default
-          let newSort = null;
-
-          if (header.field === sortedHeader.field) {
-            newSort = order;
-          }
-
-          return {
-            ...header,
-            sort: newSort,
-          };
-        });
-      };
-
-      const order = getNextSortOrder(column.sort);
-
-      const newHeaders = changeHeadersSort({
-        headers: headers.value,
-        sortedHeader: column,
-        order,
-      });
-
-      headers.value = newHeaders;
-    };
-    const setupPersistence = async () => {
-      const { restore: restoreFields } = usePersistedStorage({
-        name: 'fields',
-        value: fields,
-        storages: [
-          PersistedStorageType.LocalStorage,
-          PersistedStorageType.Route,
-        ],
-        storagePath: id,
-        onStore: (save, { name }) => {
-          const value = fields.value.join(',');
-          return save({ name, value });
-        },
-        onRestore: async (restore, name) => {
-          const value = (await restore(name)) as string;
-          if (value) {
-            return updateFields(value.split(','));
-          }
-        },
-      });
-
-      const { restore: restoreSort } = usePersistedStorage({
-        name: 'sort',
-        value: sort,
-      });
-
-      return Promise.allSettled([restoreFields(), restoreSort()]);
-    };
-
-    return {
-      headers,
-      shownHeaders,
-      fields,
-      sort,
-
-      updateShownHeaders,
-      updateSort,
-
-      setupPersistence,
-      $reset,
-    };
-  });
-};

package/src/modules/Filters/v2/pagination/createTablePaginationStore.ts

@@ -1,64 +0,0 @@
-import { defineStore } from 'pinia';
-import { ref } from 'vue';
-
-import { usePersistedStorage } from '../persist/usePersistedStorage.ts';
-
-export const createTablePaginationStore = (namespace: string) => {
-  const id = `${namespace}/pagination`;
-
-  return defineStore(id, () => {
-    const page = ref(1);
-    const size = ref(10);
-    const next = ref(false);
-
-    const updatePage = (newPage: number) => {
-      page.value = newPage;
-    };
-
-    const updateSize = (newSize: number) => {
-      size.value = newSize;
-    };
-
-    const $reset = () => {
-      page.value = 1;
-      size.value = 10;
-      next.value = false;
-    };
-
-    const setupPersistence = () => {
-      const { restore: restorePage } = usePersistedStorage({
-        name: 'page',
-        value: page,
-        onRestore: async (restore, name) => {
-          const value = await restore(name);
-          const numValue = +value;
-          if (numValue) page.value = numValue;
-        },
-      });
-
-      const { restore: restoreSize } = usePersistedStorage({
-        name: 'size',
-        value: size,
-        onRestore: async (restore, name) => {
-          const value = await restore(name);
-          const numValue = +value;
-          if (numValue) size.value = numValue;
-        },
-      });
-
-      return Promise.allSettled([restorePage(), restoreSize()]);
-    };
-
-    return {
-      page,
-      size,
-      next,
-
-      updatePage,
-      updateSize,
-
-      setupPersistence,
-      $reset,
-    };
-  });
-};

package/src/modules/Filters/v2/persist/PersistedStorage.types.ts

@@ -1,51 +0,0 @@
-import { Ref, WatchOptions } from 'vue';
-
-export enum PersistedStorageType {
-  LocalStorage = 'localStorage',
-  Route = 'route',
-}
-
-// in route query, or in localStorage
-export type PersistStorableValue = string;
-
-export type PersistableValue =
-  | PersistStorableValue
-  | { toString: () => PersistStorableValue };
-
-export interface StorageLike {
-  getItem(key: string): Promise<PersistableValue | null>;
-
-  setItem(key: string, value: PersistableValue): Promise<void>;
-
-  removeItem(key: string): Promise<void>;
-}
-
-export interface PersistedPropertyConfig {
-  name: string;
-  value: Ref<PersistableValue>;
-  storages?: PersistedStorageType | PersistedStorageType[];
-  storagePath?: string;
-  startWatchManually?: boolean;
-  watchConfig?: WatchOptions;
-  onStore?: (
-    save: ({
-      name,
-      value,
-    }: {
-      name: string;
-      value: PersistableValue;
-    }) => Promise<void>,
-    { value, name },
-  ) => Promise<void>;
-  onRestore?: (
-    restore: (name: string) => Promise<PersistableValue>,
-    name: string,
-  ) => Promise<void>;
-}
-
-export interface PersistedStorageController {
-  watch: () => void;
-  unwatch: () => void;
-  restore: () => Promise<void>;
-  reset: () => Promise<void>;
-}

package/src/modules/Filters/v2/persist/useLocalStoragePersistedStorage.ts

@@ -1,37 +0,0 @@
-import { StorageLike } from './PersistedStorage.types.ts';
-
-const separator = ';';
-
-const makePath = (storagePath: string, key: string) => `${storagePath}/${key}`;
-
-export const useLocalStoragePersistedStorage = ({
-  storagePath = '',
-}: {
-  storagePath: string;
-}): StorageLike => {
-  const getItem = async (key: string) => {
-    const value = localStorage.getItem(makePath(storagePath, key));
-    try {
-      return value.split(separator).join();
-    } catch {
-      return value;
-    }
-  };
-
-  const setItem = async (key: string, inputValue: string | string[]) => {
-    const value = Array.isArray(inputValue)
-      ? inputValue.join(separator)
-      : inputValue;
-    localStorage.setItem(makePath(storagePath, key), value);
-  };
-
-  const removeItem = async (key: string) => {
-    localStorage.removeItem(makePath(storagePath, key));
-  };
-
-  return {
-    getItem,
-    setItem,
-    removeItem,
-  };
-};

package/src/modules/Filters/v2/persist/usePersistedStorage.ts

@@ -1,151 +0,0 @@
-import { watch } from 'vue';
-
-import {
-  PersistableValue,
-  PersistedPropertyConfig,
-  PersistedStorageController,
-  PersistedStorageType,
-} from './PersistedStorage.types.ts';
-import { useLocalStoragePersistedStorage } from './useLocalStoragePersistedStorage.ts';
-import { useRoutePersistedStorage } from './useRoutePersistedStorage.ts';
-
-export const usePersistedStorage = ({
-  name,
-  value,
-  storages: configStorages = [PersistedStorageType.Route],
-  storagePath,
-  startWatchManually = false,
-  onStore,
-  onRestore,
-}: PersistedPropertyConfig): PersistedStorageController => {
-  let unwatch = null;
-
-  const setItemFns = [];
-  const getItemFns: Array<(name: string) => Promise<PersistableValue>> = [];
-  const removeItemFns = [];
-
-  const composedValueGetter = async (
-    name: string,
-  ): Promise<PersistableValue[]> => {
-    const settledResults = await Promise.allSettled(
-      getItemFns.map((getter) => getter(name)),
-    );
-
-    return settledResults.reduce((acc, result) => {
-      if (result.status === 'fulfilled') {
-        return [...acc, result.value];
-      }
-      return acc;
-    }, []);
-  };
-
-  const storages = Array.isArray(configStorages)
-    ? configStorages
-    : [configStorages];
-
-  /*
-  order matters, as the first storage in the list has the highest priority
-   */
-  if (storages.includes(PersistedStorageType.Route)) {
-    const { setItem, getItem, removeItem } = useRoutePersistedStorage();
-    setItemFns.push(setItem);
-    getItemFns.push(getItem);
-    removeItemFns.push(removeItem);
-  }
-
-  if (storages.includes(PersistedStorageType.LocalStorage)) {
-    const { setItem, getItem, removeItem } = useLocalStoragePersistedStorage({
-      storagePath,
-    });
-    setItemFns.push(setItem);
-    getItemFns.push(getItem);
-    removeItemFns.push(removeItem);
-  }
-
-  const startWatch = () => {
-    unwatch = watch(
-      value,
-      async () => {
-        /*
-       if onStore callback is provided,
-        call custom logic for storing value
-       */
-        if (onStore) {
-          /*
-         wrap all setItemFns in one callback
-          so that onStore is called only once on each value change
-         */
-          const save = async ({ name, value: storedValue }) => {
-            setItemFns.forEach((setter) => {
-              setter(name, storedValue);
-            });
-          };
-          await onStore(save, { name, value });
-        } else {
-          /*
-       else, perform default storing logic
-       */
-          const storedValue = value.value;
-          setItemFns.forEach((setter) => {
-            setter(name, storedValue);
-          });
-        }
-      },
-      { deep: true },
-    );
-  };
-
-  const restore = async () => {
-    /*
-       if onRestore callback is provided,
-        call custom logic for restoring value
-       */
-    if (onRestore) {
-      /*
-         wrap all getItemFns in one callback
-          so that onRestore is called only once on each value change
-         */
-      const restore = async (name: string) => {
-        const restoredValues = await composedValueGetter(name);
-        /*
-         not sure if value to restore should be picked automatically
-          before running onRestore
-         */
-        return restoredValues.find((value) => {
-          return value != null;
-        });
-      };
-      await onRestore(restore, name);
-    } else {
-      /*
-       else, perform default restoring logic
-       */
-      const restoredValues = await composedValueGetter(name);
-      const restoredValue = restoredValues.find((value) => value !== null);
-
-      if (restoredValue !== undefined) {
-        value.value = restoredValue;
-      }
-    }
-    /*
-      start watching after restoring value to prevent restored value
-       from storing again
-     */
-    if (!startWatchManually) {
-      startWatch();
-    }
-  };
-
-  const reset = async () => {
-    await Promise.all(removeItemFns.map((removeItem) => removeItem(name)));
-  };
-
-  const endWatch = () => unwatch && unwatch();
-
-  return {
-    watch: startWatch,
-    unwatch: endWatch,
-    restore,
-    reset,
-  };
-};

package/src/modules/Filters/v2/persist/useRoutePersistedStorage.ts

@@ -1,41 +0,0 @@
-import { useRoute, useRouter } from 'vue-router';
-
-import { StorageLike } from './PersistedStorage.types.ts';
-
-export const useRoutePersistedStorage = (): StorageLike => {
-  const router = useRouter();
-  const route = useRoute();
-
-  const getItem = async (key: string) => {
-    return route.query[key];
-  };
-
-  const setItem = async (key: string, value: string | string[]) => {
-    await router.replace({
-      name: route.name,
-      params: route.params,
-      hash: route.hash,
-      query: {
-        ...route.query,
-        [key]: value,
-      },
-    });
-  };
-
-  const removeItem = async (key: string) => {
-    const query = { ...route.query };
-    delete query[key];
-    await router.replace({
-      name: route.name,
-      params: route.params,
-      hash: route.hash,
-      query,
-    });
-  };
-
-  return {
-    getItem,
-    setItem,
-    removeItem,
-  };
-};