Variable default

Type declaration

• version: string

• download: (url: string, filename: string, type?: string) => void

• RGBToHex: (r: number, g: number, b: number) => string

• addEvent: typeof addEvent

• all: <T = unknown>(arr: T[], fn: AnyFunction) => boolean

• any: <T = unknown>(arr: T[], fn: AnyFunction) => boolean

• getCache: (name: string) => any

• setCache: <T = unknown>(name: string, value: T, seconds?: string | number) => void

• delCache: (name: string) => void

• getSession: (name: string) => any

• setSession: <T = unknown>(name: string, value: T, seconds?: string | number) => void

• delSession: (name: string) => void

• getCookie: (name: string) => any

• getCookies: () => Record<string, string>

• setCookie: <T extends string | number | boolean>(
      name: string,
      value: T,
      seconds: string | number,
      path?: string,
      samesite?: boolean,
  ) => void

• delCookie: (name: string) => void

• camel2Dash: (string: string) => string

• cleanData: (data: any, map: any[] | AnyObject, nullFix?: any) => any

• clearAttr: (string: string) => string

• clearHtml: (string: string) => string

• escape: (string: string) => string

• unescape: (string: string) => string

• client: (
      name?: string,
      userAgent?: string,
  ) =>
      | boolean
      | {
          IE: boolean;
          GECKO: boolean;
          WEBKIT: boolean;
          OPERA: boolean;
          TRIDENT: boolean;
          MOBILE: boolean;
          IOS: boolean;
          ANDROID: boolean;
          IPHONE: boolean;
          IPAD: boolean;
          QQBROWSER: boolean;
          WEIXIN: boolean;
          QQ: null
          | RegExpMatchArray;
      }

• complement: <T = unknown>(...args: T[][]) => T[]

• contains: (arr: any[], item: any) => boolean

• CSVToArray: (data: string, delimiter?: string, omitFirstRow?: boolean) => string[][]

• arrayToCSV: <T extends unknown[][]>(arr: T, delimiter?: string) => string

• CSVToJSON: (data: string, delimiter?: string) => any[]

• JSONToCSV: (arr: any[], columns: any[], delimiter?: string) => string

• cutCHSString: (str: string, len?: number, hasDot?: boolean) => string

• dash2Camel: (string: string) => string

• decodeBase64: (input: string) => string

• decodeUtf8: (utftext: string) => string

• delay: () => {
      map: any;
      register(id: string, fn: AnyFunction, time: number, boo: boolean): void;
      destroy(id: string): void;
  }

• encodeBase64: (input: string) => string

• encodeUtf8: (string: string) => string

• extend: {
      (
          target: ExtendObjectData,
          ...args: ArrayOneMore<ExtendObjectData>,
      ): ExtendObjectData;
      (
          target: boolean,
          ...args: ArrayOneMore<ExtendObjectData>,
      ): ExtendObjectData;
      (
          target: ExtendArrayData,
          ...args: ArrayOneMore<ExtendArrayData>,
      ): ExtendArrayData;
      (target: boolean, ...args: ArrayOneMore<ExtendArrayData>): ExtendArrayData;
  }

• clone: <T = any>(parent: T) => T

• fillIPv6: (ip: string) => string

• fixNumber: (number: string | number, n?: number) => number

• mapTemplate: (
      tmp: string,
      data: Record<string, unknown> | (value: string) => unknown,
  ) => string

• getAppVersion: (
      appName: string,
      withApp?: boolean,
      userAgent?: string,
  ) => string | boolean | null

• appVersion: {
      (appName: string): string | null;
      (appName: string, ua: string): string | null;
      (appName: string, ua: boolean): string | null;
      (appName: string, ua: string, ignoreCase: boolean): string | null;
  }

• getCHSLength: (str: string) => number

• getDirParam: (url: string) => DirParamType

• compareVersion: (input: string, compare: string) => -1 | 0 | 1

• getNumber: (string: string) => string

• getOsVersion: (
      osName: string,
      withOS?: boolean,
      userAgent?: string,
  ) => string | boolean | null

• osVersion: (ua?: string) => OsVersion | null

• browserVersion: (ua?: string) => BrowserVersion | null

• getQueryParam: {
      (key: string): string | undefined;
      (key: string, url: string): string | undefined;
  }

• getQueryParams: {
      (url: string): Record<string, string>;
      (url: boolean): Record<string, unknown>;
      (url: string, covert: boolean): Record<string, unknown>;
  }

• getProperty: {
      <T extends Record<string, any>>(
          target: T,
          prop: string | () => string,
          defaultValue?: any,
      ): any;
      <T extends any[]>(
          target: T,
          prop: string | () => string,
          defaultValue?: any,
      ): any;
  }

• randomColor: (
      min?: number | [number, number, number],
      max?: number | [number, number, number],
  ) => string

• randomNumber: (min?: number, max?: number) => number

• randomNumbers: (n?: number, sum?: number, noZero?: boolean) => number[]

• randomString: {
      (len?: number, options?: boolean | RandomStringOptions): string;
      (
          len?: boolean | RandomStringOptions,
          options?: boolean | RandomStringOptions,
      ): string;
  }

• shuffle: {
      (value: string, size?: number): string;
      <T extends unknown[] = unknown[]>(value: T, size?: number): T;
  }

• fingerprint: (domain?: string) => null | string

• getScrollPosition: () => undefined | "bottom" | "top"

• getType: <T = any>(
      target: T,
  ) =>
      | "string"
      | "number"
      | "bigint"
      | "boolean"
      | "symbol"
      | "undefined"
      | "object"
      | "function"
      | "window"
      | "error"
      | "promise"
      | "math"
      | "document"
      | "navigator"
      | "global"
      | "array"
      | "null"
      | "date"
      | "regexp"

• getFileType: (
      url: string,
  ) => {
      suffix: string;
      type:
          | "audio"
          | "video"
          | "image"
          | "other"
          | "word"
          | "txt"
          | "excel"
          | "pdf"
          | "ppt"
          | "zip";
  }

• sorter: (
      locales?: string | string[],
      options?: CollatorOptions,
  ) => <T = string, P = string>(a: T, b: P) => number

• sortPinyin: <T = string, P = string>(a: T, b: P, options?: CollatorOptions) => number

• parseUrlParam: (url: string, covert?: boolean) => Record<string, unknown>

• spliceUrlParam: <T extends Record<string, unknown>>(
      params: T,
      covert?: boolean | SpliceUrlParamOptions,
  ) => string

• safeParse: (data: string, covert?: boolean) => any

• safeStringify: (data: any, covert?: boolean) => string

• getUrlParam: {
      (key: string): string | undefined;
      (key: string, url: string): string | undefined;
  }

• getUrlParams: {
      (url: string): Record<string, string>;
      (url: boolean): Record<string, unknown>;
      (url: string, covert: boolean): Record<string, unknown>;
  }

• intersect: <T = unknown>(...args: T[][]) => T[]

• isDigitals: (str: string) => boolean

• isExitsFunction: (name: string) => boolean

• isExitsVariable: (name: string) => boolean

• isEqual: <T, P>(a: T, b: P) => boolean

• isWindow: (target: any) => target is Window

• isObject: (target: any) => target is Object

• isDate: (target: any) => target is Date

• isRegExp: (target: any) => target is RegExp

• isArray: (target: any) => target is any[]

• isIterable: <T = any>(target: T | Iterable<T>) => target is Iterable<T>

• isPlainObject: (target: unknown) => target is PlainObject

• isDarkMode: () => boolean

• inBrowser: boolean

• inNodeJs: boolean

• isNumberBrowser: (userAgent?: string) => boolean

• minus: <T = unknown>(...args: T[][]) => T[]

• nextIndex: (min?: number, max?: number) => number

• nextVersion: (
      version: string,
      type?:
          | "major"
          | "minor"
          | "patch"
          | "premajor"
          | "preminor"
          | "prepatch"
          | "prerelease",
      preid?: string,
  ) => string

• punctualTimer: {
      <TArgs extends any[]>(
          handler: (args: void) => void,
          delay: number,
          args?: TArgs,
      ): PunctualTimerReturns;
      <TArgs extends any[]>(
          handler: (...args: TArgs) => void,
          delay: number,
          args?: TArgs,
      ): PunctualTimerReturns;
  }

• promiseFactory: <T extends object>(
      original: T,
      resolver: () => Promise<any>,
  ) => T & PromiseLike<T>

• waiting: (milliseconds: number, throwOnTimeout?: boolean) => Promise<void>

• awaitTo: {
      <T, E = Error>(promise: Promise<T>): Promise<[E, undefined] | [null, T]>;
      <P extends [] | readonly unknown[], E = Error>(
          promise: PromiseAll<P>,
      ): Promise<[E, undefined] | [null, P]>;
      <T, P extends [] | readonly unknown[], E = Error>(
          promise: Promise<T>,
          ...promises: PromiseAll<P>,
      ): Promise<[E, undefined] | [null, [T, ...P]]>;
  }

• arrayBufferToBase64: (input: ArrayBuffer, mime?: string) => string

• arrayBufferToBlob: (input: ArrayBuffer, mime?: string) => Blob

• base64ToArrayBuffer: (input: string) => Uint8Array<ArrayBuffer> | Buffer<ArrayBuffer>

• base64ToBlob: (input: string) => Blob

• base64ToFile: (input: string, fileName: string) => File

• blobToArrayBuffer: (input: Blob) => Promise<ArrayBuffer | null>

• blobToBase64: (input: Blob) => Promise<string | null>

• blobToUrl: (input: Blob) => string

• fileToBase64: (input: File) => Promise<string | null>

• svgToBlob: (input: string) => Blob

• urlToBlob: (input: string) => Promise<Blob | null>

• openUrl: (url: string) => void

• copy: (value: any) => undefined | boolean

• pattern: {
      any: RegExp;
      number: RegExp;
      string: RegExp;
      postcode: RegExp;
      url: RegExp;
      username: RegExp;
      float: RegExp;
      email: RegExp;
      mobile: RegExp;
      chinese: RegExp;
      tel: RegExp;
      qq: RegExp;
      pass: RegExp;
      json: RegExp;
      arrjson: RegExp;
      array: RegExp;
      isjson: RegExp;
      textarea: RegExp;
      mac: RegExp;
      ip4: RegExp;
      ip4_pri: RegExp;
  }

• removeEvent: (element: AnyObject, type: string, handler: AnyFunction) => void

• searchObject: (
      tree: object | any[],
      expression: any,
      keySet: SearchKeySet,
      number?: number,
  ) => any[]

• setProperty: (target: any, prop: string | () => string, value: any) => any

• stopBubble: (e: Event) => boolean

• stopDefault: (e: Event) => boolean

• toThousands: (num: string | number) => string

• trim: (string: string) => string

• union: <T = unknown>(...args: T[][]) => T[]

• unique: <T = unknown>(arr: T[]) => T[]

• upperFirst: (string: string) => string

• uuid: () => string

• windowSize: () => WindowSizeObj

• loadSource: (url: string, option: string | SourceOptions) => Promise<boolean | string>

• mountCss: (src: string, option?: CssOptions) => Promise<boolean>

• mountImg: (src: string, option?: ImgOptions) => Promise<boolean | string>

• mountJs: (src: string, option?: JsOptions) => Promise<boolean>

• mountStyle: (css: string, option?: StyleOptions) => Promise<boolean>

• preloader: {
      (images: string): HTMLImageElement;
      (images: string[]): Record<string, HTMLImageElement>;
  }