@zdzz/shared v0.1.0

共享工具类

一个共享工具类包，包含了常见的数据类型判断、工具函数、业务工具

基础工具

1. 数据类型判断

2. 常用工具类

业务相关

1. cache

import { WebCache } from "@zdzz/shared";
import { name, version } from "../../package.json";
type WebCacheEnum = "Token";
const webCache = new WebCache<WebCacheEnum>({
  projectName: name,
  projectVersion: version,
});

export function setToken(token: string) {
  webCache.set("Token", token);
}

export function getToken() {
  return webCache.get<string>("Token");
}

export function removeToken() {
  webCache.remove("Token");
}

2. http

import { createAxios, createRuoyiAxiosTransform } from "@zdzz/shared";
import { getToken, removeToken } from "@/utils/cache";
import { useMessage } from "@/hooks/useMessage";
const apiUrl = "***";

const { createErrorMsg } = useMessage();
const transform = createRuoyiAxiosTransform({
  removeToken,
  getToken,
  createMessage: (a, b) => createErrorMsg(b),
});
export const defHttp = createAxios(apiUrl, { transform });

3. dict

import type {
  DictBaseOptions,
  DictDataListRecord,
  DictDataLoadingRecord,
  LoadDict,
  OriginDictData,
} from "@zdzz/shared";
import { computed, toRefs, unref } from "vue";
import { defHttp } from "@/utils/defHttp";
import { Dict } from "@zdzz/shared";
export type DictTypes =
  | "sys_user_sex"
  | "sys_normal_disable"
  | "sys_notice_type";

const getDicts: LoadDict<DictTypes> = (dictType) => {
  return new Promise<OriginDictData[]>((resolve, reject) => {
    defHttp
      .get<ResponseData<OriginDictData[]>>(
        {
          url: `/api/sys/type/${dictType}`,
        },
        {
          withToken: false,
          ignoreCancelToken: true,
        }
      )
      .then((res) => {
        if (!res.data) {
          reject(
            `[Dictionary error] Get dictionary data \`${dictType}\` with null.Please check your dictionary key with \`${dictType}\`.`
          );
        } else {
          resolve(res.data);
        }
      })
      .catch((e) => {
        reject(e);
      });
  });
};
interface BaseDicts<DT extends string, F, L> {
  dicts: DictDataListRecord<DT>;
  dictsLoading: DictDataLoadingRecord<DT>;
  format: F; // typeof format;
  load: L; // typeof load;
}
export function useDicts<DT extends DictTypes = DictTypes>(
  dts: DT[],
  options: Partial<DictBaseOptions> = {}
) {
  const dict = new Dict<DT>(dts, getDicts, options);
  // debug
  Dict.debug = true;
  const format = dict.format.bind(dict);
  const load = dict.load.bind(dict);
  const dicts = computed(() => dict.data.value);
  const dictsLoading = computed(() => dict.loading.value);
  const useRuoyiDictsReturn = {
    format,
    load,
    dicts,
    dictsLoading,
    ...toRefs(unref(dict.data)),
    ...toRefs(unref(dict.loading)),
  };

 
  return useRuoyiDictsReturn;