@webitel/ui-sdk 24.12.85 → 24.12.87

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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,89 @@
+import { computed, ref } from 'vue';
+import { defineStore } from 'pinia';
+import { sortToQueryAdapter } from '../../../../scripts';
+import { SortSymbols } from '../../../../scripts/sortQueryAdapters';
+
+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 updateShownHeaders = () => {};
+
+    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;
+    };
+
+    return {
+      headers,
+      shownHeaders,
+      fields,
+      sort,
+
+      updateShownHeaders,
+      updateSort,
+    };
+  });
+};

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

@@ -0,0 +1,54 @@
+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 = async () => {
+      const { restore: restorePage } = usePersistedStorage({
+        name: 'page',
+        value: page,
+      });
+
+      const { restore: restoreSize } = usePersistedStorage({
+        name: 'size',
+        value: size,
+      });
+
+      return Promise.allSettled([restorePage(), restoreSize()]);
+    };
+
+    return {
+      page,
+      size,
+      next,
+
+      updatePage,
+      updateSize,
+
+      setupPersistence,
+      $reset,
+    };
+  });
+};

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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,31 @@
+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);
+    } 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

@@ -0,0 +1,150 @@
+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 }) => {
+          // await Promise.allSettled(
+          //   setItemFns.map((setItem) => {
+          //     return setItem({ 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

@@ -0,0 +1,41 @@
+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,
+  };
+};

package/src/modules/Filters/v2/table/createTableStore.store.ts

@@ -0,0 +1,180 @@
+import set from 'lodash/fp/set';
+import { defineStore, storeToRefs } from 'pinia';
+import { type Ref, ref, watch } from 'vue';
+
+import { createTableFiltersStore } from '../filters/createTableFiltersStore.ts';
+import { createTableHeadersStore } from '../headers/createTableHeadersStore.ts';
+import { createTablePaginationStore } from '../pagination/createTablePaginationStore.ts';
+import {
+  PatchItemPropertyParams,
+  TableStore,
+  useTableStoreParams,
+} from '../types/tableStore.types.ts';
+
+export const createTableStore = <Entity extends { id: string; etag?: string }>(
+  namespace: string,
+  { parentId, apiModule, headers }: useTableStoreParams<Entity>,
+) => {
+  const usePaginationStore = createTablePaginationStore(namespace);
+  const useHeadersStore = createTableHeadersStore(namespace, { headers });
+  const useFiltersStore = createTableFiltersStore(namespace);
+
+  return defineStore(namespace, (): TableStore<Entity> => {
+    const paginationStore = usePaginationStore();
+    const { page, size, next } = storeToRefs(paginationStore);
+    const {
+      updatePage,
+      updateSize,
+      // $reset: $resetPaginationStore,
+      $patch: $patchPaginationStore,
+      setupPersistence: setupPaginationPersistence,
+    } = paginationStore;
+
+    const headersStore = useHeadersStore();
+    const { headers, shownHeaders, fields, sort } = storeToRefs(headersStore);
+    const { updateSort, updateShownHeaders } = headersStore;
+
+    const filtersStore = useFiltersStore();
+    const { filtersManager, isRestoring: isFiltersRestoring } =
+      storeToRefs(filtersStore);
+    const {
+      hasFilter,
+      addFilter,
+      updateFilter,
+      deleteFilter,
+      setupPersistence: setupFiltersPersistence,
+    } = filtersStore;
+
+    const dataList: Ref<Entity[]> = ref([]);
+    const selected: Ref<Entity[]> = ref([]);
+    const error = ref(null);
+    const isLoading = ref(false);
+
+    const loadDataList = async () => {
+      isLoading.value = true;
+      $patchPaginationStore({ next: false });
+
+      const params = {
+        ...filtersManager.value.getAllValues(),
+        page: page.value,
+        size: size.value,
+        sort: sort.value,
+        fields: fields.value,
+        parentId,
+      };
+
+      try {
+        const { items, next } = await apiModule.getList(params);
+
+        dataList.value = items;
+        $patchPaginationStore({ next });
+      } catch (err) {
+        error.value = err;
+        throw err;
+      } finally {
+        isLoading.value = false;
+      }
+    };
+
+    const patchItemProperty = async ({
+      index,
+      path,
+      value,
+    }: PatchItemPropertyParams) => {
+      const item = dataList.value[index];
+      const changes = {};
+      set(path, value, changes);
+
+      try {
+        await apiModule.patch({
+          changes,
+          parentId,
+          id: item.id,
+          etag: item.etag,
+        });
+        set(path, value, item);
+      } catch (err) {
+        await loadDataList();
+        throw err;
+      }
+    };
+
+    const deleteEls = async (_els: Entity[]) => {
+      const els = Array.isArray(_els) ? _els : [_els];
+      const deleteEl = (el: Entity) => {
+        return apiModule.delete({ id: el.id });
+      };
+
+      try {
+        await Promise.all(els.map(deleteEl));
+      } finally {
+        await loadDataList();
+      }
+    };
+
+    const initialize = async () => {
+      await Promise.allSettled([
+        setupPaginationPersistence(),
+        setupFiltersPersistence(),
+      ]);
+
+      let loadingAfterFiltersChange = false;
+
+      watch(
+        [() => filtersManager.value.getAllValues(), sort, size],
+        async () => {
+          loadingAfterFiltersChange = true;
+          updatePage(1);
+          await loadDataList();
+          loadingAfterFiltersChange = false;
+        },
+        /* filtersManager requires deep watching for its values */
+        { deep: true },
+      );
+
+      watch([page], () => {
+        if (!loadingAfterFiltersChange) {
+          return loadDataList();
+        }
+      });
+
+      return loadDataList();
+    };
+
+    return {
+      dataList,
+      selected,
+      error,
+      isLoading,
+
+      page,
+      size,
+      next,
+
+      headers,
+      shownHeaders,
+      fields,
+      sort,
+
+      filtersManager,
+      isFiltersRestoring,
+
+      initialize,
+
+      loadDataList,
+      patchItemProperty,
+      deleteEls,
+
+      updatePage,
+      updateSize,
+
+      updateSort,
+      updateShownHeaders,
+
+      hasFilter,
+      addFilter,
+      updateFilter,
+      deleteFilter,
+    };
+  });
+};