/**
 * @param {Promise} 需要包装的Promise
 * @returns {any[]} [0]为Promise.prototype.then返回的结果，[1]为Promise.prototype.catch返回的结果
 */
import { waitFor } from 'kayran'

const [res] = await waitFor(new Promise((resolve, reject) => {
  resolve('res')
}))
console.log(res) // 'res'

const [, err] = await waitFor(new Promise((resolve, reject) => {
  reject('err')
}))
console.log(err) // 'err'

/**
 * @param {File|string} 音视频url或二进制文件
 * @returns {Promise<number>} 时长 单位秒 四舍五入
 */

import { getMediaDuration } from 'kayran'

getMediaDuration('https://xxx.mp4')

/**
 * @param {any} 需要判断的变量
 * @returns {string} 变量类型（全小写） 如string null undefined file...
 */

import { typeOf } from 'kayran'

typeOf(1) // 'number'

import 'kayran/dist/style.css'
import { highlightError } from 'kayran'

/**
 * @param {string|Element|NodeList} [el='.el-form .el-form-item.is-error'] 错误元素或其DOMString
 */
highlightError(el)

// 或

/**
 * @param {object} config? 配置
 * @param {string|Element|NodeList} [config.el='.el-form .el-form-item.is-error'] 错误元素或其DOMString
 * @param {(Element) => void} [config.scrollIntoView=el => el.scrollIntoView({ 
 *                                                           behavior: 'smooth', 
 *                                                           block: 'center' 
 *                                                         })
 *                            ] 定位至错误元素的实现
 * @param {(Element) => boolean} [config.isVisible=element => {
 *                                                   const rect = element.getBoundingClientRect()
 *                                                   const yInView = rect.top < window.innerHeight && rect.bottom > 0
 *                                                   const xInView = rect.left < window.innerWidth && rect.right > 0
 *                                                   return yInView && xInView
 *                                                 }
 *                               ] 判断错误元素是否处于可见范围的实现
 */
highlightError(config)

/**
 * @param {Element} 需要判断的元素
 * @returns {boolean} 是否触发溢出省略
 */

import { isEllipsis } from 'kayran'

isEllipsis(document.querySelector('.text'))

/**
 * @param {any} 需要判断的变量
 * @returns {boolean} 结果
 */

import { isEmpty, notEmpty } from 'kayran'

isEmpty(0)  // false
isEmpty({}) // true
isEmpty([]) // true

/**
 * @param {object} 需要转换的对象
 * @returns {FormData} 结果
 */

import { jsonToFormData } from 'kayran'

const formData = jsonToFormData({
  a: 1
})

formData.get('a') // 1

/**
 * @param {object} innerText style标签的innerText 或传对象指定style的各项属性
 * @returns {Promise<Element>}
 */

import { paramFilter } from 'kayran'

await paramFilter({
  a: 1,
  b: NaN
})

/**
 * @param {string} url 需要判断的url
 * @returns {boolean}
 */

import { isSameOrigin } from 'kayran'

isSameOrigin('www.google.com')

/**
 * 获取当前url某个查询参数的值
 * 支持微信公众号授权特例：授权后会重定向回来并在链接中加入一个code参数 但微信没有考虑hash路由的情况 所以获取这个code需要特殊处理
 * @param {object}
 *        {string} key 查询参数的key 如果为空 则返回查询参数映射的对象 可以解构使用
 *        {string} [mode='hash'] router模式 可选值'history'/'hash'
 *        {boolean} del 是否在url中删除该值（删除会引发页面刷新）
 * @returns {string|object} 查询参数中key对应的value / 如果key为空 则返回查询参数整个对象
 */

import { parseQueryString } from 'kayran'

const code = parseQueryString('code')

//or

const { code } = parseQueryString()

/**
 * @param {string|object} src link url
 * @returns {Promise}
 */

import { loadLink } from 'kayran'

await loadLink('https://cdn.bootcdn.net/ajax/libs/normalize/8.0.1/normalize.min.css')

/**
 * @param {string|object} src 脚本url
 * @returns {Promise}
 */

import { loadScript } from 'kayran'

loadScript('https://cdn.jsdelivr.net/npm/vue/dist/vue.js').then(e => {
  console.log(Vue)
})

/**
 * @param {string|object|HTMLElement} arg style元素的innerText 或传对象指定style的各项属性 或style元素本身
 * @returns {Promise<HTMLElement>}
 */

import { loadStyle } from 'kayran'

await loadStyle(`
ul {
  list-style: none;
}
`)

/**
 * @param {string} 需要校验的内容
 * @returns {string} 校验失败提示信息 如果校验通过则返回''
 */

import { validator } from 'kayran'

const { idCard } = validator

const errMsg = idCard('xxx')

if (errMsg) {
  Toast(errMsg) // '格式不正确'
  return
}

// 如果仅仅想知道是否校验通过

!idCard('xxx') // true通过 false失败

/**
 * @param {string|number} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { lng } = validator

/**
 * @param {string|number} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { lat } = validator

/**
 * @param {string|number} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { phone } = validator

/**
 * @param {string} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { ipv4 } = validator

/**
 * @param {string} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { ipv6 } = validator

/**
 * @param {string} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { url } = validator

/**
 * @param {string} 需要判断的字符串
 * @param {object}
 *        {string} mediaType 媒体类型，可选值参考 https://en.wikipedia.org/wiki/Data_URI_scheme
 *        {boolean} [scheme=true] 是否包含前缀
 * @returns {boolean} 结果
 */

import { validator } from 'kayran'

const { base64 } = validator

base64(1, {
  mediaType: 'image',
  scheme: false
}) // false

/**
 * @param {string|number} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { idCard } = validator

/**
 * @param {string|number} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { postcode } = validator

/**
 * @param {string|number} 需要判断的值
 * @param {object}
 *        {boolean} [multiple=true] 是否允许多个
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { tel } = validator

/**
 * @param {string} 需要判断的值
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { email } = validator

/**
 * @param {string} 需要判断的值
 * @param {
 *          number |
 *          [number, number] |
 *          {
 *            min?: number
 *            max?: number
 *          }
 *        }
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { len } = validator

len('123', [1, 3])

/**
 * @param {string|number} 需要判断的值
 * @param {
 *          string | 
 *          {
 *            range?: string
 *            positiveSign?: boolean
 *          }
 *        }
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { int } = validator

int(0, '(0,2)')

/**
 * @param {string|number} 需要判断的值
 * @param {
 *          string |
 *          {
 *            range?: string,
 *            decimalPlaces?: number | [number, number]
 *          }
 *        }
 * @returns {string} 判断结果
 */

import { validator } from 'kayran'
const { decimal } = validator

decimal(80, '[80,+∞]')

decimal('80.1', {
  decimalPlaces: [0, 1]
})