@sarafapp/iron_core 1.0.64 → 1.0.67

package/src/composables/UseLoadingStatus.ts

@@ -1,65 +0,0 @@
-import { computed, ref } from "vue";
-import { LoadingStatus } from "../constants";
-
-export function useLoadingStatus() {
-  const loadingStatus = ref<Set<LoadingStatus>>(new Set<LoadingStatus>());
-
-  const isFetchingList = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchList);
-  });
-
-  const isFetchingItem = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchItem);
-  });
-
-  const isFetchingLastItems = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchLastItems);
-  });
-
-  const isFetchingPreviousItems = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchPreviousItems);
-  });
-
-  const isCreating = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Create);
-  });
-
-  const isUpdating = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Update);
-  });
-
-  const isDeleting = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Delete);
-  });
-
-  const isSearching = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Search);
-  });
-
-  const isSorting = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Sort);
-  });
-
-  function setStatus(status: LoadingStatus) {
-    loadingStatus.value.add(status);
-  }
-
-  function removeStatus(status: LoadingStatus) {
-    loadingStatus.value.delete(status);
-  }
-
-  return {
-    loadingStatus,
-    isFetchingList,
-    isFetchingItem,
-    isFetchingLastItems,
-    isFetchingPreviousItems,
-    isCreating,
-    isUpdating,
-    isDeleting,
-    isSearching,
-    isSorting,
-    setStatus,
-    removeStatus,
-  };
-}

package/src/composables/UseParams.ts

@@ -1,93 +0,0 @@
-import { type Ref, ref } from "vue";
-import { SortDetail } from "../sort";
-import { BaseModel } from "../BaseModel";
-import { Params } from "../repository";
-
-const DEFAULT_PARAMS = new Params();
-
-export function useParams() {
-  const params: Ref<Params> = ref(structuredClone(DEFAULT_PARAMS));
-
-  function setNextPage() {
-    params.value.pageNumber = params.value.pageNumber + 1;
-  }
-
-  function setPreventPage() {
-    params.value.pageNumber = params.value.pageNumber - 1;
-  }
-
-  function setPageNumber(pageNumber: number) {
-    params.value.pageNumber = pageNumber;
-  }
-
-  function setItemCount(itemCount: number) {
-    params.value.itemCount = itemCount;
-  }
-
-  function setSortDetail(sortDetail: SortDetail<BaseModel>) {
-    params.value.sortDetail.key = sortDetail.key;
-    params.value.sortDetail.order = sortDetail.order;
-  }
-
-  function setFiltersBaseOnRequestBody(filters: Record<string, unknown>) {
-    for (const key in filters) {
-      setFilter(key, filters[key]);
-    }
-  }
-
-  function setFilter(key: string, value: unknown) {
-    const index = params.value.filters.findIndex(
-      (filter) => filter.key === key,
-    );
-    if (index > -1) params.value.filters[index].value = value;
-    else params.value.filters.push({ key, value });
-  }
-
-  function removeFilter(key: string) {
-    let currentParams = params.value.filters;
-    currentParams = currentParams.filter(iteratedParam => iteratedParam.key !== key)
-    params.value.filters = currentParams;
-  }
-
-  function getRequestParams() {
-    const requestParams: Record<string, unknown> = {
-      page: params.value.pageNumber,
-      count: params.value.itemCount,
-    };
-    if (params.value.sortDetail) {
-      requestParams.by = params.value.sortDetail.key;
-      requestParams.order = params.value.sortDetail.order;
-    }
-    for (const filter of params.value.filters) {
-      if (filter.value) {
-        if (typeof filter.value === 'string' || typeof filter.value === 'number') {
-          requestParams[filter.key] = filter.value;
-        } else {
-          const value = JSON.stringify(filter.value);
-          if (value !== "[]" && value !== "{}") {
-            requestParams[filter.key] = value;
-          }
-        }
-      }
-    }
-    return requestParams;
-  }
-
-  function clearParam() {
-    params.value = structuredClone(DEFAULT_PARAMS);
-  }
-
-  return {
-    params,
-    setNextPage,
-    setPreventPage,
-    setPageNumber,
-    setItemCount,
-    setSortDetail,
-    setFilter,
-    removeFilter,
-    getRequestParams,
-    clearParam,
-    setFiltersBaseOnRequestBody
-  };
-}

package/src/composables/UseRepository.ts

@@ -1,207 +0,0 @@
-import { computed, onBeforeUnmount } from "vue";
-import { useData } from "./UseData";
-import { useParams } from "./UseParams";
-import { useLoadingStatus } from "./UseLoadingStatus";
-import { type Repository, type SyncDetail } from "../repository";
-import { LoadingStatus } from "../constants";
-import { SortDetail } from "../sort";
-import { BaseModel } from "../BaseModel";
-import { Scheduler } from "../baseSchedule";
-import { type TableRenderingData, type TableService } from "../baseTable";
-
-export function useRepository<Model extends BaseModel>(
-  repository: Repository<Model>,
-) {
-  const dataManger = useData();
-  const paramsManager = useParams();
-  const loadingStatusManager = useLoadingStatus();
-
-  const scheduler = new Scheduler({
-    runAction: async () => fetchList(LoadingStatus.AutoRefresh),
-  });
-
-  const currentPageItems = computed<Model[]>(() => {
-    const pageNumber = paramsManager.params.value.pageNumber;
-    const pageSize = paramsManager.params.value.itemCount;
-    const startIndex = pageNumber * pageSize - pageSize;
-    const endIndex = pageNumber * pageSize - 1;
-    const items: Model[] = [];
-    for (let index = startIndex; index <= endIndex; index++) {
-      if (!dataManger.itemsAsArray.value[index]) break;
-      items.push(dataManger.itemsAsArray.value[index] as Model);
-    }
-    return items;
-  });
-
-  const tableRenderingData = computed<TableRenderingData<Model>>(() => {
-    return {
-      totalItems: dataManger.totalCount.value,
-      currentPage: paramsManager.params.value.pageNumber,
-      rows: dataManger.itemsAsArray.value,
-      loadingStatus: loadingStatusManager.loadingStatus.value,
-      currentPageItems: currentPageItems.value,
-    } as TableRenderingData<Model>;
-  });
-
-  const tableService = computed<TableService<Model>>(() => {
-    return {
-      getData: getTableRenderingData,
-      sort: sort,
-      paginate: fetchItemsByPageNumber,
-      fetchRows: fetchList,
-    };
-  });
-
-  const syncDetail = computed<SyncDetail>(() => {
-    return repository.getSyncDetail();
-  });
-
-  function getTableRenderingData(): TableRenderingData<Model> {
-    return tableRenderingData.value;
-  }
-
-  async function handleFetchList(query?: Record<string, unknown>) {
-    const result = await repository.fetchList(query);
-    dataManger.clearItems();
-    dataManger.addOrReplaceItems(result.items);
-    dataManger.setTotalCount(result.totalItems);
-    return result;
-  }
-
-  async function fetchList(
-    loadingStatus: LoadingStatus = LoadingStatus.FetchList,
-  ) {
-    loadingStatusManager.setStatus(loadingStatus);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(loadingStatus);
-    return result;
-  }
-
-  async function fetchWithAutoRefresh() {
-    setupAutoRefresh();
-    await fetchList();
-  }
-
-  function setupAutoRefresh() {
-    if (!syncDetail.value.shouldKeepSync) {
-      throw new Error(`The provided repository does not support auto refresh`);
-    }
-    scheduler.setupInterval(syncDetail.value.intervalInMillisecond);
-  }
-
-  function stopAutoRefresh() {
-    scheduler.clearInterval();
-  }
-
-  async function fetchItemById(id: number, shouldRemoveItem = true) {
-    loadingStatusManager.setStatus(LoadingStatus.FetchItem);
-    if (shouldRemoveItem) {
-      dataManger.clearCurrentItem();
-    }
-    const result = await repository.fetchItemById(id);
-    dataManger.setCurrentItem(result);
-    loadingStatusManager.removeStatus(LoadingStatus.FetchItem);
-    return result;
-  }
-
-  async function createItem<Body>(body: Body) {
-    loadingStatusManager.setStatus(LoadingStatus.Create);
-    const result = await repository.createItem(body);
-    if (result) {
-      dataManger.addOrReplaceItems([result]);
-    }
-    loadingStatusManager.removeStatus(LoadingStatus.Create);
-    return result;
-  }
-
-  async function updateItem<Body>(id: number, body: Body) {
-    loadingStatusManager.setStatus(LoadingStatus.Update);
-    const result = await repository.updateItem(id, body);
-    if (result) {
-      dataManger.addOrReplaceItems([result]);
-    }
-    loadingStatusManager.removeStatus(LoadingStatus.Update);
-    return result;
-  }
-
-  async function deleteItem(id: number) {
-    loadingStatusManager.setStatus(LoadingStatus.Delete);
-    await repository.deleteItem(id);
-    loadingStatusManager.removeStatus(LoadingStatus.Delete);
-    return dataManger.removeById(id);
-  }
-
-  async function fetchLastItems() {
-    paramsManager.setNextPage();
-    loadingStatusManager.setStatus(LoadingStatus.FetchLastItems);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchLastItems);
-    return result;
-  }
-
-  async function fetchPreviousItems() {
-    paramsManager.setPreventPage();
-    loadingStatusManager.setStatus(LoadingStatus.FetchPreviousItems);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchPreviousItems);
-    return result;
-  }
-
-  async function fetchItemsByPageNumber(pageNumber: number) {
-    paramsManager.setPageNumber(pageNumber);
-    loadingStatusManager.setStatus(LoadingStatus.FetchList);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchList);
-    return result;
-  }
-
-  async function search(searchedValue: string) {
-    paramsManager.setFilter("search", searchedValue);
-    loadingStatusManager.setStatus(LoadingStatus.Search);
-    dataManger.clearItems();
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.Search);
-    return result;
-  }
-
-  async function sort(sortDetail: SortDetail<Model>) {
-    paramsManager.setSortDetail(sortDetail as SortDetail<BaseModel>);
-    loadingStatusManager.setStatus(LoadingStatus.Sort);
-    dataManger.clearItems();
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.Sort);
-    return result;
-  }
-
-  async function clearFilters() {
-    paramsManager.clearParam();
-    return await fetchList();
-  }
-
-  onBeforeUnmount(() => {
-    stopAutoRefresh();
-  });
-
-  return {
-    loadingStatusManager,
-    dataManger,
-    paramsManager,
-    tableRenderingData,
-    fetchList,
-    fetchWithAutoRefresh,
-    setupAutoRefresh,
-    stopAutoRefresh,
-    fetchItemById,
-    createItem,
-    updateItem,
-    deleteItem,
-    fetchLastItems,
-    fetchPreviousItems,
-    fetchItemsByPageNumber,
-    search,
-    sort,
-    clearFilters,
-    tableService,
-    currentPageItems,
-  };
-}

package/src/composables/UseState.ts

@@ -1,30 +0,0 @@
-import { computed, ref, type Ref } from "vue";
-
-export function useState<T>(initial: T, ttl: number = 300_000): Ref<T> {
-  const state = ref<T>(structuredClone(initial));
-  let timer: ReturnType<typeof setTimeout> | null = null;
-
-  function resetTimer() {
-    if (timer) clearTimeout(timer);
-    if (ttl > 0) {
-      timer = setTimeout(() => {
-        state.value = initial;
-      }, ttl);
-    }
-  }
-
-  const computedState = computed<T>({
-    get() {
-      resetTimer();
-      return state.value;
-    },
-    set(value: T) {
-      state.value = value;
-      resetTimer();
-    },
-  });
-
-  resetTimer();
-
-  return computedState;
-}

package/src/composables/UseStaticTableService.ts

@@ -1,45 +0,0 @@
-import { computed, ref } from 'vue'
-import { LoadingStatus } from '../constants'
-import { SortDetail } from '../sort'
-import type { TableRenderingData, TableService } from '../baseTable'
-
-export function useStaticTableService<Model>(initialRows: Model[]) {
-  const tableRows = ref<Model[]>(initialRows);
-
-  const staticTableService = computed<TableService<Model>>(() => {
-    return {
-      getData(): TableRenderingData<Model> {
-        return {
-          totalItems: tableRows.value.length,
-          currentPageItems: tableRows.value as Model[],
-          loadingStatus: new Set<LoadingStatus>(),
-          rows: tableRows.value as Model[],
-          currentPage: 1
-        }
-      },
-      async sort(_sortDetail: SortDetail<Model>) {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      },
-      async fetchRows() {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      },
-      async paginate(_nextPage: number, _pageSize: number) {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      }
-    }
-  })
-
-  return {
-    tableRows,
-    staticTableService
-  }
-}

package/src/composables/index.ts

@@ -1,7 +0,0 @@
-export { useRepository } from "./UseRepository";
-export { useData } from "./UseData";
-export { useParams } from "./UseParams";
-export { useLoadingStatus } from "./UseLoadingStatus";
-export { useStaticTableService } from "./UseStaticTableService";
-export * from "./UseCrud";
-export * from "./UseState";

package/src/constants/Constants.ts

@@ -1,126 +0,0 @@
-export const enum LoadingStatus {
-  FetchList = "fetchList",
-  AutoRefresh = "autoRefresh",
-  FetchItem = "fetchItem",
-  FetchLastItems = "fetchLastItems",
-  FetchPreviousItems = "fetchPreviousItems",
-  Create = "CREATE",
-  Update = "UPDATE",
-  Delete = "DELETE",
-  Search = "SEARCH",
-  Sort = "SORT",
-  Success = "SUCCESS",
-  Error = "ERROR",
-  Idle = "IDLE",
-}
-
-export const enum DialogDimensions {
-  Width = "width",
-  Height = "height",
-  DefaultWidth = 500,
-  DefaultHeight = 350,
-  MinimalAvailableSize = 0,
-}
-
-export const enum SortOrder {
-  ASC = "ASC",
-  DESC = "DESC",
-}
-
-export const enum SortOrderTableHeader {
-  ASC = "ascend",
-  DESC = "descend",
-}
-
-export const enum TableHeaderAlign {
-  Left = "left",
-  Right = "right",
-  Center = "center",
-}
-
-export const enum HeaderType {
-  Text = "text",
-}
-
-export const enum CellType {
-  Text = "text",
-  ACTION = "action",
-  Tag = "tag",
-  Iban = "iban",
-  BankCard = "bankCard",
-  Symbol = "symbol",
-  TradeDetail = "tradeDetail",
-  SymbolPrice = "symbolPrice",
-  TradeSymbol = "tradeSymbol",
-  Price = "price",
-  DynamicCurrencyPrice = "dynamicCurrencyPrice",
-  TradeDate = "tradeDate",
-  RequestResponseIdentity = "requestResponseIdentity",
-  Image = 'image'
-}
-
-export const enum TableConstants {
-  MINIMAL_LOADABLE_HEADER_COUNT = 0,
-  DEFAULT_ITEM_COUNT_PER_PAGE = 20,
-  PAGINATION_POSITION = "bottomCenter",
-}
-
-export const enum ApplicationTheme {
-  FontFamily = "IRANSansX",
-}
-
-export const enum ApplicationDrawerStatus {
-  Open = "open",
-  Close = "close",
-}
-
-export const enum ToastType {
-  Success = "success",
-  Failure = "error",
-  Info = "info",
-  Warning = "warning",
-}
-
-export const enum ToastLocation {
-  BottomLeft = "bottomLeft",
-}
-
-export const enum StatusCode {
-  NotFound = 404,
-  Unauthorized = 401,
-  ServerError = 500,
-}
-
-export const enum FormValidationStatus {
-  Invalid,
-  Valid,
-}
-
-export const enum StorageKeys {
-  Theme = "theme",
-  AccessList = "accessList",
-  Token = 'token',
-  SSO_ACCESS_LIST = 'ssoAccessList'
-}
-
-export const enum ApplicationTheme {
-  Light = "light",
-  Dark = "dark",
-}
-
-export const enum ComponentSize {
-  Small = "small",
-  Medium = "medium",
-  Large = "large",
-}
-
-export const enum StoreNames {
-  Dialog = "dialog",
-  Drawer = "drawer",
-  Module = "module",
-  Toast = "toast",
-}
-
-export const enum Symbols {
-  USDT = "USDT",
-}

package/src/constants/index.ts

@@ -1,19 +0,0 @@
-export {
-  LoadingStatus,
-  DialogDimensions,
-  SortOrder,
-  SortOrderTableHeader,
-  TableHeaderAlign,
-  HeaderType,
-  CellType,
-  TableConstants,
-  ApplicationDrawerStatus,
-  ToastType,
-  ToastLocation,
-  StatusCode,
-  FormValidationStatus,
-  StorageKeys,
-  ApplicationTheme,
-  StoreNames,
-  Symbols,
-} from "./Constants";