vite-uni-dev-tool 0.0.1

package/dev/plugins/uniGlobalComponents/uniGlobalComponents.js

@@ -0,0 +1,5 @@
+"use strict";const o=/<template[^>]*>([\s\S]*?)<\/template>/;function m({pages:s,components:a}){return{name:"uni-global-components",enforce:"pre",transform(t,n){if(n.endsWith(".vue")){const l=t.includes("<template>");if(s.pages.some(e=>n.includes(e.path))&&l){const e=t.match(o);if(e&&e[1]){const p=`${e[1].trim()}
+${a.join(`
+`)}`;return{code:t.replace(o,`<template>
+${p}
+</template>`),map:null}}}}return{code:t,map:null}}}}module.exports=m;

package/dev/shims-uni.d.ts

@@ -0,0 +1,43 @@
+/// <reference types='@dcloudio/types' />
+import 'vue';
+
+declare module 'vue' {
+  type Hooks = App.AppInstance & Page.PageInstance;
+  interface ComponentCustomOptions extends Hooks {}
+}
+
+
+declare global {
+  interface Uni {
+    /**
+     * 小程序下拥有的环境变量
+     * 目前微信小程序下支持
+     */
+    env: {
+      USER_DATA_PATH: string;
+    };
+
+
+    __dev__console: {
+      log: Function;
+      error: Function;
+      warn: Function;
+      info: Function;
+      time: Function;
+      timeEnd: Function;
+      clear: Function;
+      count: Function;
+      countReset: Function;
+      assert: Function;
+      debug: Function;
+      dir: Function;
+      dirxml: Function;
+      group: Function;
+      groupCollapsed: Function;
+      groupEnd: Function;
+      table: Function;
+      timeStamp: Function;
+      trace: Function;
+    }
+  }
+}

package/dev/type.ts

@@ -0,0 +1,188 @@
+import { DevEvent } from './devEvent';
+export declare namespace DevTool {
+  type Page = {
+    index?: number;
+    path: string;
+    sort?: number;
+    name?: string;
+    isNav?: boolean;
+    style: {
+      navigationBarTitleText?: string;
+    };
+  };
+
+  type Message = {
+    type: 'success' | 'error';
+    data: string;
+    time: number;
+  };
+
+  type WS = {
+    url: string;
+    /**
+     * -1: error
+     * 0:connecting
+     * 1:open
+     * 2:closing
+     * 3:closed
+     */
+    readyState?: string;
+    headers?: { key: string; value: string }[];
+    method?: string;
+    protocols?: string[];
+    message: Message[];
+  };
+
+  type Nav = {
+    pagePath: string;
+    text: string;
+  };
+  type PagesJSON = {
+    pages: Page[];
+    tabBar: {
+      list: Nav[];
+    };
+  };
+
+  type DevToolOptions = {
+    /** 是否拦截Promise.reject 最好不要拦截 默认禁用 */
+    enableInterceptPromiseReject?: boolean;
+    /** 打开窗口时隐藏按钮 */
+    openWindowHideButton?: boolean;
+    /** 最大的console条数 */
+    consoleMaxSize?: number;
+    /** 最大的网络请求条数 */
+    networkMaxSize?: number;
+    /** 最大的上传文件条数 */
+    uploadMaxSize?: number;
+    /** 最大的套接字消息条数 */
+    wsDataMaxSize?: number;
+    /** 最大占用缓存空间 */
+    cacheMaxSize?: number;
+    /** 所有路由信息 */
+    pagesJson?: PagesJSON;
+  } & ButtonOptions;
+
+  type ButtonOptions = Partial<{
+    /** 按钮大小 */
+    buttonSize: number;
+    /** 按钮文本 */
+    buttonText: string;
+    /** 按钮文本颜色 */
+    buttonColor: string;
+    /** 按钮字体大小 */
+    buttonFontSize: string;
+    /** 按钮背景颜色 */
+    buttonBackgroundColor: string;
+    /** 初始化时是否显示调试按钮,默认显示 */
+    initShowDevTool: boolean;
+  }>;
+
+  type NetworkItem = {
+    index: number;
+    url: string;
+    name: string;
+    method: string;
+    status: number | string;
+    time: string;
+    startTime: number;
+    endTime: number;
+    size: string;
+    headers: {
+      requestHeader: { key: string; value: any }[];
+      responseHeader: { key: string; value: any }[];
+    };
+    response: string;
+    payload: any;
+  };
+  type StorageItem = {
+    key: string;
+    _oldKey: string;
+    value: string;
+  };
+
+  /**  调试工具目前支持处理的console类型 */
+  type ConsoleType =
+    | 'log'
+    | 'info'
+    | 'warn'
+    | 'error'
+    | 'timeEnd'
+    | 'time'
+    | 'clear'
+    | 'count';
+
+  /** 不支持处理的console类型 */
+  type OriginalConsoleType =
+    | 'assert'
+    | 'count'
+    | 'countReset'
+    | 'debug'
+    | 'dir'
+    | 'dirxml'
+    | 'group'
+    | 'groupCollapsed'
+    | 'groupEnd'
+    | 'table'
+    | 'trace'
+    | 'profile'
+    | 'profileEnd'
+    | 'timeStamp';
+
+  type ConsoleItem = {
+    type: string;
+    args: any[];
+    position: string;
+    time: string;
+    stack?: string;
+  };
+
+  type UploadItem = {
+    index: number;
+    url?: string;
+    filePath?: string;
+    formData?: Record<string, any>;
+    method?: string;
+    headers?: {
+      requestHeader?: { key: string; value: unknown }[];
+      responseHeader?: { key: string; value: unknown }[];
+    };
+    response?: Record<string, any>;
+    files?: any[];
+    fileType?: string;
+    name?: string;
+    status: number | string;
+    timeout?: number;
+    startTime?: number;
+    endTime?: number;
+    /** 上传进度 */
+    progress?: number;
+    /** 已上传长度 */
+    totalBytesSent?: number;
+    /** 预计上传总长度 */
+    totalBytesExpectedToSend?: number;
+  };
+
+  type WindowData = {
+    devToolVisible?: boolean;
+    consoleList?: ConsoleItem[];
+    networkList?: NetworkItem[];
+    storageList?: StorageItem[];
+    routeList?: Page[];
+    vuexList?: Record<string, any>;
+    piniaList?: Record<string, any>;
+    systemInfo?: Record<string, any>;
+    deviceInfo?: Record<string, any>;
+    windowInfo?: Record<string, any>;
+    netWorkStatus?: Record<string, any>;
+    wsList?: WS[];
+    size?: number;
+    sizeFormat?: string;
+    uploadList?: UploadItem[];
+  };
+
+  type DevInterceptOptions = {
+    event: DevEvent;
+    enableInterceptPromiseReject?: boolean;
+  };
+}

package/dev/utils/date.ts

@@ -0,0 +1,75 @@
+export function getCurrentDate() {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const hour = date.getHours();
+  const minute = date.getMinutes();
+  const second = date.getSeconds();
+  return `${year}-${month.toString().padStart(2, '0')}-${day
+    .toString()
+    .padStart(2, '0')} ${hour.toString().padStart(2, '0')}:${minute
+    .toString()
+    .padStart(2, '0')}:${second?.toString().padStart(2, '0')}`;
+}
+
+/**
+ * 格式化时间
+ *
+ * @export
+ * @param {(Date | string | number)} date
+ * @param {string} format
+ * @return {*}  {string}
+ */
+export function formatDate(
+  date: Date | string | number,
+  format: string,
+): string {
+  let dateObj: Date;
+
+  if (date instanceof Date) {
+    dateObj = date;
+  } else {
+    dateObj = new Date(date);
+  }
+
+  if (isNaN(dateObj.getTime())) {
+    throw new Error('Invalid date');
+  }
+
+  const formatMap: Record<string, string | number> = {
+    YYYY: dateObj.getFullYear(),
+    MM: String(dateObj.getMonth() + 1).padStart(2, '0'),
+    M: dateObj.getMonth() + 1,
+    DD: String(dateObj.getDate()).padStart(2, '0'),
+    D: dateObj.getDate(),
+    HH: String(dateObj.getHours()).padStart(2, '0'),
+    H: dateObj.getHours(),
+    hh: String(dateObj.getHours() % 12 || 12).padStart(2, '0'),
+    h: dateObj.getHours() % 12 || 12,
+    mm: String(dateObj.getMinutes()).padStart(2, '0'),
+    m: dateObj.getMinutes(),
+    ss: String(dateObj.getSeconds()).padStart(2, '0'),
+    s: dateObj.getSeconds(),
+    SS: String(dateObj.getMilliseconds()).padStart(3, '0'),
+    S: dateObj.getMilliseconds(),
+    A: dateObj.getHours() >= 12 ? 'PM' : 'AM',
+    a: dateObj.getHours() >= 12 ? 'pm' : 'am',
+  };
+
+  return format.replace(
+    /YYYY|MM|DD|HH|hh|mm|ss|SS|A|a|M|D|H|h|m|s|S/g,
+    (match) => formatMap[match].toString(),
+  );
+}
+
+/**
+ * 休眠
+ *
+ * @export
+ * @param {number} ms
+ * @return {*}
+ */
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dev/utils/file.ts

@@ -0,0 +1,121 @@
+/**
+ * 获取文件路径
+ *
+ * @export
+ * @return {*}
+ */
+export function getFilePath() {
+  return new Promise((resolve, reject) => {
+    if (plus) {
+      plus.io.resolveLocalFileSystemURL('_downloads', function (dirEntry) {
+        resolve(dirEntry.fullPath);
+      });
+    } else {
+      reject();
+    }
+  });
+}
+
+/**
+ * 写入文件
+ *
+ * @param {string} filePath
+ * @param {string} content
+ */
+function writeContentToFile(filePath: string, content: string) {
+  plus.io.requestFileSystem(
+    plus.io.PUBLIC_DOCUMENTS,
+    function (fs) {
+      fs.root?.getFile(
+        filePath,
+        { create: true },
+        function (fileEntry) {
+          fileEntry.createWriter(function (writer) {
+            writer.onwriteend = function () {
+              console.log('[DevTool] 写入文件成功' + filePath);
+              uni.showToast({
+                icon: 'none',
+                title: '写入文件成功' + filePath,
+                duration: 10 * 1000,
+              });
+            };
+            writer.onerror = function (e) {
+              console.log('[DevTool] 写入文件失败' + JSON.stringify(e));
+              uni.showToast({
+                icon: 'none',
+                title: '写入文件失败',
+              });
+            };
+            writer.write(content);
+          });
+        },
+        function (e) {
+          uni.showToast({
+            icon: 'none',
+            title: '获取文件失败',
+          });
+          console.log('[DevTool] 获取文件失败' + JSON.stringify(e));
+        },
+      );
+    },
+    function (e) {
+      uni.showToast({
+        icon: 'none',
+        title: '获取文件系统失败',
+      });
+      console.log('[DevTool] 获取文件系统失败' + JSON.stringify(e));
+    },
+  );
+}
+
+export async function saveTxtFileApp(data: string, fileName: string) {
+  try {
+    const filePath = (await getFilePath()) + `${Date.now()}_${fileName}.txt`;
+    writeContentToFile(filePath, data);
+  } catch (error) {
+    console.log('[DevTool] ' + JSON.stringify(error));
+  }
+}
+
+export async function saveTextFileH5(data: string, fileName: string) {
+  // 创建 Blob 对象
+  const blob = new Blob([data], { type: 'text/plain' });
+
+  // 生成临时 URL
+  const url = URL.createObjectURL(blob);
+
+  // 创建下载链接
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = fileName;
+
+  // 触发点击下载
+  link.click();
+}
+
+export async function saveTextFileMicro(data: string, fileName: string) {
+  const fs = uni.getFileSystemManager();
+  const fileNameDate = `${fileName}_${Date.now()}.txt`;
+  const filePath = `${uni?.env?.USER_DATA_PATH ?? 'Download'}/${fileNameDate}`;
+  fs.writeFile({
+    data,
+    filePath,
+    success: (res) => {
+      console.log('[DevTool] 写入文件成功' + filePath);
+      console.log(
+        `[DevTool] 文件位置：内部存储/Android/data/comm.tencent.mm/MicroMsg/wxanewfiles/手动查找最新文件夹/${fileNameDate}`,
+      );
+      uni.showToast({
+        title: '写入文件成功' + filePath,
+        icon: 'none',
+      });
+    },
+    fail: (error) => {
+      console.log('[DevTool] 写入文件失败' + JSON.stringify(error));
+      uni.showToast({
+        title: '写入文件失败' + JSON.stringify(error),
+        icon: 'none',
+      });
+    },
+  });
+}

package/dev/utils/function.ts

@@ -0,0 +1,192 @@
+type ThrottleOptions = {
+  leading?: boolean;
+  trailing?: boolean;
+};
+
+/**
+ * 创建一个节流函数，在指定时间间隔内只执行一次原函数
+ * @param func 需要节流的函数
+ * @param wait 等待时间（毫秒）
+ * @param options 配置选项
+ * @param options.leading 是否在开始时立即执行
+ * @param options.trailing 是否在延迟结束后执行最后一次调用
+ * @returns 节流后的函数
+ */
+
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number,
+  options: ThrottleOptions = {},
+): (...args: Parameters<T>) => ReturnType<T> | undefined {
+  let timeout: NodeJS.Timeout | null = null;
+  let lastArgs: Parameters<T> | null = null;
+  let lastThis: any = null;
+  let result: ReturnType<T> | undefined;
+  let lastCallTime: number | null = null;
+
+  const { leading = true, trailing = true } = options;
+
+  const invokeFunc = (time: number) => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = null;
+    lastCallTime = time;
+    result = func.apply(thisArg, args!);
+    return result;
+  };
+
+  const leadingEdge = (time: number) => {
+    lastCallTime = time;
+    timeout = null;
+    return leading ? invokeFunc(time) : undefined;
+  };
+
+  const trailingEdge = (time: number) => {
+    timeout = null;
+    if (lastArgs && trailing) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = null;
+    return result;
+  };
+
+  const remainingWait = (time: number) => {
+    if (lastCallTime === null) return wait;
+    const timeSinceLastCall = time - lastCallTime;
+    return wait - timeSinceLastCall;
+  };
+
+  const shouldInvoke = (time: number) => {
+    if (lastCallTime === null) return true;
+    const timeSinceLastCall = time - lastCallTime;
+    return timeSinceLastCall >= wait || timeSinceLastCall < 0;
+  };
+
+  const timerExpired = () => {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timeout = setTimeout(timerExpired, remainingWait(time));
+    return undefined;
+  };
+
+  const throttled = function (this: any, ...args: Parameters<T>) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+
+    lastArgs = args;
+    lastThis = this;
+
+    if (isInvoking) {
+      if (timeout === null) {
+        return leadingEdge(time);
+      }
+    }
+
+    if (timeout === null) {
+      timeout = setTimeout(timerExpired, wait);
+    }
+
+    return result;
+  };
+
+  throttled.cancel = () => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    lastCallTime = null;
+    timeout = lastArgs = lastThis = null;
+  };
+
+  return throttled;
+}
+
+type DebouncedFunction<T extends (...args: any[]) => any> = ((
+  ...args: Parameters<T>
+) => ReturnType<T> | undefined) & {
+  cancel: () => void;
+  flush: () => ReturnType<T> | undefined;
+};
+
+/**
+ * 创建一个防抖函数，该函数在最后一次调用后等待指定时间才执行。
+ * @param func 需要防抖的函数
+ * @param wait 等待时间（毫秒）
+ * @param immediate 是否在第一次调用时立即执行
+ * @returns 防抖后的函数
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number,
+  immediate: boolean = false,
+): DebouncedFunction<T> {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  let lastArgs: Parameters<T> | null = null;
+  let lastThis: ThisParameterType<T> | null = null;
+  let result: ReturnType<T> | undefined;
+  let lastCallTime: number | null = null;
+
+  const later = (): void => {
+    const last = lastCallTime !== null ? Date.now() - lastCallTime : 0;
+
+    if (last < wait && last >= 0) {
+      timeout = setTimeout(later, wait - last);
+    } else {
+      timeout = null;
+      if (!immediate) {
+        if (lastArgs !== null && lastThis !== null) {
+          result = func.apply(lastThis, lastArgs);
+          lastArgs = lastThis = null;
+        }
+      }
+    }
+  };
+
+  const debounced = function (
+    this: ThisParameterType<T>,
+    ...args: Parameters<T>
+  ): ReturnType<T> | undefined {
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = Date.now();
+
+    const callNow = immediate && timeout === null;
+
+    if (!timeout) {
+      timeout = setTimeout(later, wait);
+    }
+
+    if (callNow) {
+      result = func.apply(this, args);
+      lastArgs = lastThis = null;
+    }
+
+    return result;
+  };
+
+  debounced.cancel = (): void => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+      timeout = null;
+      lastArgs = lastThis = null;
+      lastCallTime = null;
+    }
+  };
+
+  debounced.flush = (): ReturnType<T> | undefined => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+      timeout = null;
+      if (!immediate) {
+        if (lastArgs !== null && lastThis !== null) {
+          result = func.apply(lastThis, lastArgs);
+          lastArgs = lastThis = null;
+        }
+      }
+    }
+    return result;
+  };
+
+  return debounced;
+}

package/dev/utils/index.ts

@@ -0,0 +1,25 @@
+export { isNil, isBoolean, isNumber, isObject, isArray } from './language';
+export {
+  setValueByPath,
+  getValueByPath,
+  calculateObjectSize,
+  formatStorageSize,
+  serializeCircular,
+} from './object';
+
+export { throttle, debounce } from './function';
+
+export {
+  getFilePath,
+  saveTextFileH5,
+  saveTextFileMicro,
+  saveTxtFileApp,
+} from './file';
+
+export { getCurrentPagePath } from './page';
+
+export { getCurrentDate, formatDate, sleep } from './date';
+
+export { hightLight } from './string';
+
+export { getWifiIp, getDeviceMac, getLanIp, getMicroAppIp } from './ip';