create-meadminjs 1.0.0

package/template/meadmin/view/index/src/utils/fileUpload.ts

@@ -0,0 +1,156 @@
+import { FileInfo, uploadFileApi } from '@/api/file.js';
+import { UploadProgressEvent, UploadRawFile, UploadRequestOptions } from 'element-plus';
+import SparkMD5 from 'spark-md5';
+import md5WorkerURL from './fileMd5Work.js?url';
+let md5Worker: Worker;
+if (!import.meta.env.SSR) {
+  md5Worker = new Worker(md5WorkerURL, { type: 'module' });
+}
+
+export class UploadAjaxError extends Error {
+  name = 'UploadAjaxError';
+  status: number;
+  method: string;
+  url: string;
+
+  constructor(message: string, status: number, method: string, url: string) {
+    super(message);
+    this.status = status;
+    this.method = method;
+    this.url = url;
+  }
+}
+
+/**
+ * 获取文件md5
+ * @param file
+ * @param chunkSize
+ * @param progress
+ * @returns
+ */
+const getMd5 = (file: UploadRawFile, chunkSize = 1024 * 1024, progress?: (progress: string) => void) =>
+  new Promise<string>((resolve, reject) => {
+    const workHandler = (e: MessageEvent) => {
+      const data = e.data;
+      if (data.uid !== file.uid) {
+        return;
+      }
+      if (data.status === 'success') {
+        md5Worker.removeEventListener('message', workHandler);
+        resolve(data.md5);
+      } else if (data.status === 'progress') {
+        // 计算中，更新进度
+        progress?.(data.percent);
+      } else if (data.status === 'failed') {
+        md5Worker.removeEventListener('message', workHandler);
+        // 计算中，更新进度
+        reject(data.error);
+      }
+    };
+    // worker 的监听
+    md5Worker.addEventListener('message', workHandler);
+    // 通知 worker 计算 MD5
+    md5Worker.postMessage({ file, chunkSize, uid: file.uid });
+  });
+
+//执行分片上传
+const uploadChunksExecute = (file: UploadRawFile, currentChunk: number, chunkSize: number, data: UploadRequestOptions['data'] = {}) =>
+  new Promise<Partial<FileInfo>>((resolve, reject) => {
+    try {
+      const start = currentChunk * chunkSize;
+      const end = start + chunkSize >= file.size ? file.size : start + chunkSize;
+      const fileReader = new FileReader();
+      fileReader.onload = async (e) => {
+        try {
+          const formData = new FormData();
+          const upFile = new File([e.target!.result || ''], file.name, { type: file.type });
+          data.start = start + '';
+          data.chunkMd5 = SparkMD5.ArrayBuffer.hash(e.target!.result as ArrayBuffer);
+          Object.keys(data).forEach((key) => {
+            formData.append(key, Array.isArray(data[key]) ? String(data[key]) : data[key]);
+          });
+          formData.append('file', upFile);
+          //执行文件上传
+          return resolve(await uploadFileApi()(formData));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      fileReader.onerror = (error) => {
+        reject(error);
+      };
+      fileReader.readAsArrayBuffer(File.prototype.slice.call(file, start, end));
+    } catch (e) {
+      reject(e);
+    }
+  });
+/**
+ * 文件分片上传
+ * @param file
+ * @param chunkSize
+ * @param data
+ * @param progress
+ * @returns
+ */
+const uploadChunks = (file: UploadRawFile, chunkSize: number, data: UploadRequestOptions['data'] = {}, progress?: (progress: string) => void) =>
+  new Promise(async (resolve, reject) => {
+    try {
+      let currentChunk = 0;
+      const chunks = Math.ceil(file.size / chunkSize); // 总分片数
+      if (chunks > 1) {
+        //先上传一个分片确保校验和秒传
+        const res = await uploadChunksExecute(file, currentChunk, chunkSize, Object.assign(data, { chunkIndex: currentChunk + '', over: '0' }));
+        if (res.id) {
+          progress?.('100');
+          return resolve(res);
+        }
+        currentChunk++;
+        progress?.(((currentChunk / chunks) * 100).toFixed(2));
+        //一次并发上传3个分片
+        const parallelNum = 3;
+        for (; currentChunk < chunks - 1; ) {
+          const promiseArr = [];
+          for (let i = 0; i < parallelNum; i++) {
+            if (currentChunk < chunks - 1) {
+              promiseArr.push(uploadChunksExecute(file, currentChunk, chunkSize, Object.assign(data, { chunkIndex: currentChunk + '', over: '0' })));
+              currentChunk++;
+            }
+          }
+          await Promise.all(promiseArr);
+          progress?.(((currentChunk / chunks) * 100).toFixed(2));
+        }
+      }
+      //确保上传完其余分片再上传最后一个分片
+      const res = await uploadChunksExecute(file, currentChunk, chunkSize, Object.assign(data, { chunkIndex: currentChunk + '', over: '1' }));
+      progress?.('100');
+      return resolve(res);
+    } catch (e) {
+      reject(e);
+    }
+  });
+
+//上传请求兼容 element-plus上传事件
+export const fileUpload = async (options: UploadRequestOptions) => {
+  const chunkSize = 1024 * 1024;
+  const progressEvt = new ProgressEvent('uploadProgress', {
+    lengthComputable: true,
+    loaded: 0,
+    total: 100,
+  }) as UploadProgressEvent;
+  progressEvt.percent = 0;
+  // 将 MD5 值放到请求参数里
+  options.data.md5 = await getMd5(options.file, chunkSize, (process) => {
+    //md5进度占总进度5%
+    progressEvt.percent = (+process * 5) / 100;
+    options.onProgress(progressEvt);
+  });
+  options.data.chunk = '1';
+  options.data.name = options.file.name;
+  // 上传分片,第一个分片会查询文件是否存在
+  const res = await uploadChunks(options.file, chunkSize, options.data, (process) => {
+    //上传进度占总进度95%
+    progressEvt.percent = (+process * 95) / 100 + 5;
+    options.onProgress(progressEvt);
+  });
+  return res; //调用onSuccess和return后都会触发Success事件，这里只返回不调用，否则会触发两遍Success事件；
+};

package/template/meadmin/view/index/src/utils/helper.ts

@@ -0,0 +1,261 @@
+import dayjs from 'dayjs';
+import { clone, cloneDeep } from 'lodash-es';
+import { SearchTreeOptions, default as XEUtils } from 'xe-utils';
+
+/**
+ * 对象中的每个可便利元素按序执行一个由您提供的 reducer 函数，
+ * 每一次运行 reducer 会将先前元素的计算结果作为参数传入，
+ * 最后将其结果汇总为单个返回值。
+ * @param object 用户遍历的对象
+ * @param callbackfn  “reducer” 函数，包含四个参数：
+ *  previousValue：上一次调用 callbackFn 时的返回值。在第一次调用时，其值则为 initialValue。
+ *  currentValue：数组中正在处理的元素。
+ *  currentKey：数组中正在处理的元素的key。
+ *  object：用于遍历的d对象。
+ * @param initialValue  作为第一次调用 callback 函数时参数 previousValue 的值
+ * @returns
+ */
+export function objectRreduce<T, P extends Record<string, any> = Record<string, any>>(
+  object: P,
+  callbackfn: (previousValue: T, currentValue: P[keyof P], currentKey: string, object: P) => T,
+  initialValue: T,
+): T {
+  for (const i in object) {
+    if (Object.hasOwn(object, i)) {
+      initialValue = callbackfn(initialValue, object[i], i, object);
+    }
+  }
+  return initialValue;
+}
+
+/**
+ * 合并对象的value（value必须为数组）
+ * @param object
+ * @returns
+ */
+export function concatObjectValue<T, P extends Record<string, T[]> = Record<string, T[]>>(object: P) {
+  return objectRreduce(
+    object,
+    (currentValue, previousValue) => {
+      return currentValue.concat(previousValue || []);
+    },
+    [] as T[],
+  );
+}
+
+/**
+ * 文件名转驼峰
+ * @param fileName
+ * @param nameTemplate
+ * @returns
+ */
+export const fileToHump = function (fileName: string): string {
+  const index = fileName.lastIndexOf('.');
+  if (index > 0) {
+    fileName = fileName.slice(0, index);
+  }
+  const fileNameArr = fileName.replace(/\\/g, '/').split('/');
+  if (fileNameArr[fileNameArr.length - 1] === 'index' || fileNameArr[fileNameArr.length - 1] === 'Index') {
+    fileNameArr.pop();
+  }
+  for (let i = 1, len = fileNameArr.length; i < len; i++) {
+    fileNameArr[i] = fileNameArr[i].slice(0, 1).toUpperCase() + fileNameArr[i].slice(1);
+  }
+  return fileNameArr.join('');
+};
+
+/**
+ * 混色
+ * @param color1  16进制颜色1
+ * @param color2  16进制颜色2
+ * @param opacity 透明度0-1
+ * @returns
+ */
+export const mixColor = function (color1: string, color2: string, opacity: number) {
+  let red1 = parseInt(color1.slice(1, 3), 16);
+  let green1 = parseInt(color1.slice(3, 5), 16);
+  let blue1 = parseInt(color1.slice(5, 7), 16);
+  if (opacity === 0) {
+    return [red1, green1, blue1].toString();
+  }
+  const red2 = parseInt(color2.slice(1, 3), 16);
+  const green2 = parseInt(color2.slice(3, 5), 16);
+  const blue2 = parseInt(color2.slice(5, 7), 16);
+  red1 += Math.round(opacity * (red2 - red1));
+  green1 += Math.round(opacity * (green2 - green1));
+  blue1 += Math.round(opacity * (blue2 - blue1));
+  return '#' + red1.toString(16) + green1.toString(16) + blue1.toString(16);
+};
+
+/**
+ * 获取灰阶值 越小颜色越深
+ * @param color
+ * @returns
+ */
+export const getColorLuma = function (color: string) {
+  const red = parseInt(color.slice(1, 3), 16);
+  const green = parseInt(color.slice(3, 5), 16);
+  const blue = parseInt(color.slice(5, 7), 16);
+  return red * 0.299 + green * 0.587 + blue * 0.114;
+};
+
+/**
+ * 树形结构搜索
+ */
+type TreeData<Key extends string[]> = {
+  [k in Key[number]]: string | number;
+} & { [k: string]: any };
+export const searchTreeTable = function <Key extends string[], T extends TreeData<Key>>(
+  searchText: number | string,
+  searchProps: Key,
+  data: T[],
+  options: SearchTreeOptions = { children: 'children' },
+  formatStr = (str: string, filterRE: RegExp) => str.replace(filterRE, (match) => `<span class="keyword-lighten">${match}</span>`),
+) {
+  const search = XEUtils.toValueString(searchText).trim().toLowerCase();
+  if (search) {
+    const filterRE = new RegExp(search, 'gi');
+    const rest = XEUtils.searchTree(data, (item) => searchProps.some((key) => XEUtils.toValueString(item[key]).toLowerCase().indexOf(search) > -1), options);
+    XEUtils.eachTree(
+      rest,
+      (item) => {
+        searchProps.forEach((key: Key[number]) => {
+          item[key] = formatStr(XEUtils.toValueString(item[key]), filterRE) as T[Key[number]];
+        });
+      },
+      options,
+    );
+    return rest;
+  }
+  return cloneDeep(data);
+};
+
+/**
+ * 递归代理对象/数组,响应后触发update方法
+ * @param value
+ * @param update
+ * @returns
+ */
+export const proxyValue = <T extends Record<string | number, any> | any[]>(value: T, update: () => void): T => {
+  return new Proxy<T>(value, {
+    get: function (obj, prop) {
+      if (obj[prop as keyof T] && typeof obj[prop as keyof T] === 'object') {
+        return proxyValue(obj[prop as keyof T] as T, update);
+      }
+      return obj[prop as keyof T];
+    },
+    set: function (obj, prop, value) {
+      const oldV = obj[prop as keyof T];
+      obj[prop as keyof T] = value;
+      update();
+      setTimeout(() => (obj[prop as keyof T] = oldV));
+      return true;
+    },
+  });
+};
+
+export type TreeArrayItem<T, C extends string | number> = { [K in C]: TreeArrayItem<T, C>[] } & T;
+/**
+ * 数组转为树结构
+ * @param arr
+ * @param key
+ * @param parentKey
+ * @param childrenKey
+ * @returns
+ */
+export const listToTree = <T extends Record<string, any>>(arr: T[], key: keyof T = 'id' as const, parentKey: keyof T = 'parentId' as const, childrenKey = 'children' as const) => {
+  const treeNode = new Map();
+  const newArr = clone(arr);
+  newArr.forEach((item) => {
+    (item as any)[childrenKey] = [];
+    treeNode.set(item[key], item);
+  });
+  const rootArr = [] as Array<TreeArrayItem<T, typeof childrenKey>>;
+  arr.forEach((item) => {
+    const parentNode = treeNode.get(item[parentKey]);
+    if (parentNode) {
+      parentNode[childrenKey].push(item);
+    } else {
+      rootArr.push(treeNode.get(item[key]));
+    }
+  });
+  return rootArr;
+};
+
+/**
+ * 状态转boolean
+ * @param status
+ * @returns
+ */
+export const statusToBoolean = (status?: 0 | 1 | '0' | '1') => {
+  if (status === undefined) {
+    return undefined;
+  }
+
+  return status == '1';
+};
+
+/**
+ * 重置对象值，会改变原对象
+ * @param obj
+ * @param fromObj
+ * @returns
+ */
+export const resetObj = <T extends Record<any, any>>(obj: Record<any, any>, fromObj: T) => {
+  Object.keys(obj).forEach((key) => (obj[key] = undefined));
+  Object.assign(obj, fromObj);
+  return obj as T;
+};
+
+/**
+ * 递归去除数组/对象的空值值
+ * @param obj
+ * @returns
+ */
+export function clearEmptyParam<T extends Record<any, any> | any[]>(obj: T, emptyArr = [null, undefined]) {
+  if (Array.isArray(obj)) {
+    const newObj = [] as any[];
+    obj.forEach((item) => {
+      if (emptyArr.includes(item)) {
+        return;
+      } else if (Array.isArray(item)) {
+        newObj.push(clearEmptyParam(item));
+      } else if (typeof item === 'object') {
+        newObj.push(clearEmptyParam(item));
+      } else {
+        newObj.push(item);
+      }
+    });
+    return newObj;
+  } else {
+    const newObj = {} as Record<any, any>;
+    Object.keys(obj).forEach((key) => {
+      if (emptyArr.includes(obj[key])) {
+        return;
+      } else if (Array.isArray(obj[key])) {
+        newObj[key] = clearEmptyParam(obj[key]);
+      } else if (typeof obj[key] === 'object') {
+        newObj[key] = clearEmptyParam(obj[key]);
+      } else {
+        newObj[key] = obj[key];
+      }
+    });
+    return newObj;
+  }
+}
+
+//格式化表格数据
+export function formatterStr<T>({ cellValue }: { cellValue: T }) {
+  return [undefined, null, ''].includes(cellValue as any) ? '--' : (cellValue as T extends undefined | null ? string : T);
+}
+//格式化表格时间数据
+export function formatterAt<T extends string | null | undefined | Date>({ cellValue }: { cellValue: T }, formatStr = 'YYYY-MM-DD HH:mm:ss') {
+  return cellValue ? dayjs(cellValue).format(formatStr) : formatterStr({ cellValue });
+}
+
+//根据文件名判断是否是图片
+export function isImage(filename: string) {
+  const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
+  const fileExtension = filename.split('.').pop()?.toLowerCase();
+  return fileExtension ? imageExtensions.includes(fileExtension) : false;
+}

package/template/meadmin/view/index/src/utils/loading.ts

@@ -0,0 +1,71 @@
+import { LoadingOptions } from 'element-plus';
+import { throttle } from 'lodash-es';
+const loadingInstance: Record<string, ReturnType<typeof ElLoading.service>> = {};
+class Loading {
+  constructor(private execLoading: (options?: LoadingOptions) => void, private execClose: () => void) {
+    this.execLoading = execLoading;
+    this.execClose = execClose;
+  }
+  public number = 0;
+  public loading(options?: LoadingOptions, number = 1) {
+    this.number += number;
+    this.execLoading(options);
+  }
+  public throttleClose = throttle(
+    function (this: Loading) {
+      if (this.number <= 0) {
+        this.execClose();
+        this.number = 0;
+      }
+    },
+    220,
+    { leading: false },
+  );
+  public close(number = 1) {
+    if (this.number > 0) {
+      this.number -= Math.min(this.number, number);
+      this.throttleClose();
+    } else {
+      this.forceClose();
+    }
+  }
+  public forceClose() {
+    this.number = 0;
+    this.execClose();
+    this.throttleClose.cancel();
+  }
+}
+
+export const loadingObject = {
+  global: new Loading(
+    (options?: LoadingOptions) => (loadingInstance.global = ElLoading.service(options)),
+    () => loadingInstance.global?.close(),
+  ),
+  layout: new Loading(
+    (options?: LoadingOptions) => (loadingInstance.layout = ElLoading.service(Object.assign({ target: '#me-main-scroll' }, options))),
+    () => loadingInstance.layout?.close(),
+  ),
+};
+
+export function loading(options?: LoadingOptions, number = 1, mode: keyof typeof loadingObject = 'global') {
+  if (!import.meta.env.SSR) {
+    const loading = loadingObject[mode];
+    loading.loading(options, number);
+    return loading;
+  }
+  return new Loading(
+    () => {},
+    () => {},
+  );
+}
+
+export function closeLoading(force = false, number = 1, mode: keyof typeof loadingObject = 'global'): void {
+  if (!import.meta.env.SSR) {
+    const loading = loadingObject[mode];
+    if (force) {
+      loading.forceClose();
+      return;
+    }
+    loading.close(number);
+  }
+}

package/template/meadmin/view/index/src/utils/log.ts

@@ -0,0 +1,8 @@
+export default {
+  warn(message?: string, ...optionalParams: any[]) {
+    console.warn(`[meadmin warn]:${message}`, ...optionalParams);
+  },
+  error(message?: string, ...optionalParams: any[]) {
+    console.error(`[meadmin error]:${message}`, ...optionalParams);
+  },
+};

package/template/meadmin/view/index/src/utils/mitt.ts

@@ -0,0 +1,152 @@
+// 根据开源项目mitt自定义更改
+import EventEnum from '@/dict/eventEnmu';
+import { onUnmounted } from 'vue';
+type EventType = EventEnum;
+
+// An event handler can take an optional event argument
+// and should not return a value
+export type Handler<T = unknown> = (event: T) => void | Promise<void>;
+export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void | Promise<void>;
+
+// An array of all currently registered event handlers for a type
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+
+// A map of event types and their corresponding event handlers.
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+
+export interface Mitter<Events extends Record<EventType, unknown>> {
+  all: EventHandlerMap<Events>;
+
+  once: (<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>, needUnmounted?: boolean) => void) & ((type: '*', handler: WildcardHandler<Events>, needUnmounted?: boolean) => void);
+
+  on: (<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>, needUnmounted?: boolean) => void) & ((type: '*', handler: WildcardHandler<Events>, needUnmounted?: boolean) => void);
+
+  off: (<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void) & ((type: '*', handler: WildcardHandler<Events>) => void);
+
+  emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => any[]) & (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => any[]);
+}
+
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name Mitter
+ * @returns {Mitt}
+ */
+export default function mitter<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>, once?: Set<Handler<Events[keyof Events]> | WildcardHandler<Events>>) {
+  type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;
+  all = all ?? new Map();
+  once = once ?? new Set();
+
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+
+    /**
+     * Register an once event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @param needUnmounted 是否需要在Unmounted时移除监听
+     * @memberOf mitt
+     */
+    once<Key extends keyof Events>(type: Key, handler: GenericEventHandler, needUnmounted = false) {
+      const handlers: GenericEventHandler[] | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
+        once!.add(handler as Handler<Events[keyof Events]>);
+      }
+      needUnmounted &&
+        onUnmounted(() => {
+          this.off<Key>(type, handler as any);
+        });
+    },
+
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @param needUnmounted 是否需要在Unmounted时移除监听
+     * @memberOf mitt
+     */
+    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler, needUnmounted = false) {
+      const handlers: GenericEventHandler[] | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
+      }
+      needUnmounted &&
+        onUnmounted(() => {
+          this.off<Key>(type, handler as any);
+        });
+    },
+
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     * @memberOf mitt
+     */
+    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
+      const handlers: GenericEventHandler[] | undefined = all!.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+          once!.delete(handler);
+        } else {
+          all!.set(type, []);
+        }
+      }
+    },
+
+    /**
+     * Invoke all handlers for the given type.(会顺序执行)
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf mitt
+     */
+    emit<Key extends keyof Events>(type: Key, evt: Events[Key]) {
+      let handlers = all!.get(type);
+      const result = [];
+      if (handlers) {
+        handlers = (handlers as EventHandlerList<Events[keyof Events]>).slice();
+        for (const handler of handlers) {
+          const res = handler(evt);
+          if (res instanceof Promise) {
+            res.catch((error) => {
+              console.error(error);
+            });
+          }
+          result.push(res);
+          if (once!.has(handler)) {
+            this.off(type, handler);
+          }
+        }
+      }
+
+      handlers = all!.get('*');
+      if (handlers) {
+        handlers = (handlers as WildCardEventHandlerList<Events>).slice();
+        for (const handler of handlers) {
+          const res = handler(type, evt);
+          if (res instanceof Promise) {
+            res.catch((error) => {
+              console.error(error);
+            });
+          }
+          result.push(res);
+        }
+        once!.clear();
+      }
+      return result;
+    },
+  } as Mitter<Events>;
+}

package/template/meadmin/view/index/src/utils/nProgress.ts

@@ -0,0 +1,52 @@
+import nProgress from 'nprogress';
+import 'nprogress/nprogress.css';
+
+let number = 0;
+export const done = (n = 1) => {
+  number -= n;
+  if (number <= 0) {
+    if (!import.meta.env.SSR) {
+      nProgress.done();
+    }
+    number = 0;
+  } else {
+    if (!import.meta.env.SSR) {
+      nProgress.set(number / (number + n));
+    }
+  }
+};
+
+export const forceDone = () => {
+  number = 0;
+  if (!import.meta.env.SSR) {
+    nProgress.done();
+  }
+};
+
+export const start = (n = 1) => {
+  if (!import.meta.env.SSR) {
+    if (number <= 0) {
+      nProgress.start();
+      number = n;
+    } else {
+      number += n;
+    }
+  }
+};
+
+export const set = (n: number) => {
+  if (n > 0 && !import.meta.env.SSR) {
+    if (number <= 0) {
+      start(number);
+    } else {
+      nProgress.set(n);
+    }
+  }
+};
+
+export const remove = () => {
+  number = 0;
+  if (!import.meta.env.SSR) {
+    nProgress.remove();
+  }
+};