@x-edu/live-player 0.0.1

package/src/util/date.js

@@ -0,0 +1,53 @@
+import dayjs from 'dayjs'
+
+export const formatTimeDisplay = (timeKey) => {
+  const time = dayjs(timeKey)
+  const dayInWeekTexts = ['周天', '周一', '周二', '周三', '周四', '周五', '周六']
+  const dayInWeek = dayInWeekTexts[time.day()]
+
+  // 如果是同一天则显示今天 + 周几
+  if (time.isSame(dayjs(), 'day')) {
+    return `今天 ${dayInWeek}`
+  }
+  if (time.isSame(dayjs(), 'year')) {
+    return `${time.format('MM月DD日')} ${dayInWeek}`
+  }
+  return `${time.format('YYYY年MM月DD日')} ${dayInWeek}`
+}
+
+export function formatSeconds(value) {
+  let theTime = parseInt(value, 10) // 需要转换的时间秒
+  let theTime1 = 0 // 分
+  let theTime2 = 0 // 小时
+  if (theTime > 60) {
+    theTime1 = parseInt(theTime / 60, 10)
+    theTime = parseInt(theTime % 60, 10)
+    if (theTime1 > 60) {
+      theTime2 = parseInt(theTime1 / 60, 10)
+      theTime1 = parseInt(theTime1 % 60, 10)
+    }
+  }
+  let result = `${theTime1.toString().padStart(2, 0)}:${theTime.toString().padStart(2, 0)}`
+  if (theTime2 > 0) {
+    result = `${theTime2.toString().padStart(2, 0)}:${result}`
+  }
+  return result
+}
+
+export const parseAdapter = (option, dayjsClass) => {
+  const proto = dayjsClass.prototype
+  const oldParse = proto.parse
+  proto.parse = function parse(cfg) {
+    const { date } = cfg
+    const params = {
+      ...cfg
+    }
+    // ie 2019-03-13T13:33:00.000+0000 下解析有问题，全部转化下
+    if (date && typeof date === 'string') {
+      const validDate = date.replace(/(\+\d{2})(\d{2})$/, '$1:$2')
+      params.date = validDate
+      params.args[0] = validDate
+    }
+    oldParse.call(this, params)
+  }
+}

package/src/util/env.js

@@ -0,0 +1,9 @@
+const ua = window.navigator.userAgent.toLowerCase()
+
+export function isInWX() {
+  return ua.indexOf('micromessenger') > -1
+}
+
+// 判断是否在electron环境中
+export const { xElectron } = window
+export const isInElectron = !!xElectron

package/src/util/getTimestamp.js

@@ -0,0 +1,10 @@
+/**
+ * 获取时间戳
+ * @param {number} second 时间间隔，以秒为单位，超过
+ * @returns {string} 时间戳
+ */
+export function getTimestamp(second) {
+  // 转换毫秒
+  const now = Math.floor(Date.now() / 1000)
+  return Math.floor(now / second) * second
+}

package/src/util/hof.js

@@ -0,0 +1,105 @@
+import MutexLock from 'mutex-lock'
+
+/**
+ * 并发fn
+ * @param {(...args: any[]) => Promise<any>} fn
+ * @param {any} context
+ * @returns
+ */
+export function withCo(fn, context) {
+  const lock = new MutexLock()
+  const newFn = async (...args) => {
+    const lockId = await lock.request()
+    let result
+    try {
+      result = await context
+        ? await fn.bind(context)(...args)
+        : await fn(...args)
+    } catch (e) {
+      lock.release(lockId)
+      throw e
+    }
+    lock.release(lockId)
+    return result
+  }
+  return newFn
+}
+
+/**
+ * once 支持Asynchronous并发
+ * @param {(...args: any[]) => Promise<any>} fn
+ * @param {object?} option
+ * @param {any?} option.context 执行context
+ * @param {(...args) => string} option.getKey 从args中获取mutexlock key
+ * @returns
+ */
+export function withOnce(fn, {
+  context,
+  getKey,
+  timeout
+} = {}) {
+  const cacheObject = createCacheObject()
+  const lockPool = createLockPool()
+  const newFn = async (...args) => {
+    const key = getKey
+      ? getKey(...args)
+      : '__internal__key'
+    if (!cacheObject.hasKey(key)) {
+      const lock = lockPool.getLock(key)
+      const lockId = await lock.request()
+      if (!cacheObject.hasKey(key)) {
+        let result
+        try {
+          result = context
+            ? await fn.bind(context)(...args)
+            : await fn(...args)
+        } catch (e) {
+          lock.release(lockId)
+          throw e
+        }
+        cacheObject.set(key, result, timeout)
+      }
+      lock.release(lockId)
+    }
+    return cacheObject.get(key)
+  }
+  return newFn
+}
+
+/**
+ * lock池，根据key返回对应的lock
+ */
+function createLockPool() {
+  const lockObject = {}
+  return {
+    getLock(key) {
+      if (!lockObject[key]) {
+        lockObject[key] = new MutexLock()
+      }
+      return lockObject[key]
+    }
+  }
+}
+
+/**
+ *  key/value缓存对象
+ */
+function createCacheObject() {
+  const cacheObject = {}
+  return {
+    hasKey(key) {
+      return Object.prototype.hasOwnProperty.call(cacheObject, key)
+    },
+    set(key, value, timeout) {
+      cacheObject[key] = value
+      if (timeout) {
+        setTimeout(() => {
+          delete cacheObject[key]
+        }, timeout)
+      }
+    },
+    get(key) {
+      return cacheObject[key]
+    }
+  }
+}

package/src/util/live/index.js

@@ -0,0 +1,42 @@
+import dayjs from 'dayjs'
+import { PUBLIC_LIVE_STATUS, LIVING_STATUS_ADVANCE } from '@/config/publicLive'
+
+// 获取录播状态
+export const getRecordLiveStatus = (originStatus, visitTime, beginTime, endTime) => {
+  const current = dayjs(visitTime).valueOf()
+  const begin = dayjs(beginTime).valueOf()
+  const end = dayjs(endTime).valueOf()
+  if (originStatus === PUBLIC_LIVE_STATUS.COMPLETEED || originStatus === PUBLIC_LIVE_STATUS.OFFLINE) {
+    return originStatus
+  }
+  if (current < begin) {
+    return PUBLIC_LIVE_STATUS.NOSTARTED
+  }
+  if (begin <= current && end > current) {
+    return PUBLIC_LIVE_STATUS.LIVEING
+  }
+  return PUBLIC_LIVE_STATUS.COMPLETEED
+}
+
+// 我的公开课堂本地状态，直播前60分钟可以发起直播
+export const getTeacherLiveLocalStatus = (originStatus, beginTime) => {
+  if (originStatus === PUBLIC_LIVE_STATUS.COMPLETEED || originStatus === PUBLIC_LIVE_STATUS.OFFLINE) {
+    return originStatus
+  }
+  const current = dayjs()
+  const advanceTime = dayjs(beginTime).subtract(LIVING_STATUS_ADVANCE, 'minute')
+  return current.isBefore(advanceTime) ? PUBLIC_LIVE_STATUS.NOSTARTED : PUBLIC_LIVE_STATUS.LIVEING
+}
+
+export const getLocalHlsLiveStatus = (visitTime, beginTime, endTime) => {
+  const current = dayjs(visitTime).valueOf()
+  const begin = dayjs(beginTime).valueOf()
+  const end = dayjs(endTime).valueOf()
+  if (current < begin) {
+    return PUBLIC_LIVE_STATUS.NOSTARTED
+  }
+  if (begin <= current && end > current) {
+    return PUBLIC_LIVE_STATUS.LIVEING
+  }
+  return PUBLIC_LIVE_STATUS.COMPLETEED
+}

package/src/util/netUrl.js

@@ -0,0 +1,35 @@
+import memoize from 'lodash/memoize'
+
+export const isSupportWebp = memoize(() => {
+  try {
+    return document.createElement('canvas').toDataURL('image/webp', 0.5).indexOf('data:image/webp') === 0
+  } catch (err) {
+    return false
+  }
+})
+
+export default (src, size) => {
+  if (!src) {
+    return ''
+  }
+  // TODO 是否一定要encode，如果未来出问题，移除encodeURI
+  let imageSrc = src.indexOf('%') === -1
+    ? encodeURI(decodeURI(src))
+    : src
+  const linkStr = imageSrc.indexOf('?') !== -1 ? '&' : '?'
+  const type = isSupportWebp() ? 'auto' : null
+  if (size) {
+    const preStr = `${linkStr}x-bce-process=image${type ? `/format,f_${type}` : ''}/resize,limit_1,m_lfit,`
+    const sizeString = {
+      1080: `${preStr}w_1080`,
+      720: `${preStr}w_720`,
+      480: `${preStr}w_480`,
+      360: `${preStr}w_360`,
+      240: `${preStr}w_240`
+    }[size] || ''
+    imageSrc += sizeString
+  } else if (type) {
+    imageSrc += `${linkStr}x-bce-process=image/format,f_${type}`
+  }
+  return imageSrc
+}

package/src/util/object.js

@@ -0,0 +1,13 @@
+export function pick(obj, keys) {
+  if (!Array.isArray(keys)) {
+    return {}
+  }
+  return keys.reduce((result, key) => {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = obj[key]
+    }
+    return result
+  }, {})
+}
+
+export const isEmpty = (obj) => !obj || Object.keys(obj) === 0

package/src/util/push/index.js

@@ -0,0 +1,58 @@
+import { Loader } from 'fish'
+import env from '@/config/env'
+
+const url = '/3rd/im-web-push/index.umd.js'
+const { loadJS } = Loader
+let instPromise
+
+// http://git.sdp.nd/component-h5/web-im-push/-/tree/master
+class ImPush {
+  constructor() {
+    this.listeners = []
+  }
+
+  async init() {
+    if (instPromise) {
+      return instPromise
+    }
+    instPromise = loadJS(url, 'ndiot_push').then(() => {
+      window.ndiot_push.open({
+        url: env.push.host,
+        appId: env.app.appid,
+        disableSharedWorker: true
+      })
+      return window.ndiot_push
+    })
+    return instPromise
+  }
+
+  getInstance() {
+    return window.ndiot_push
+  }
+
+  addTopicListener(name, listener) {
+    const inst = this.getInstance()
+    this.listeners.push(listener)
+    inst.subscribe(name)
+    this.listen()
+  }
+
+  removeTopicListener(name, listener) {
+    const inst = this.getInstance()
+    this.listeners = this.listeners.filter((l) => l !== listener)
+    inst.unsubscribe(name)
+    this.listen()
+  }
+
+  listen() {
+    const inst = this.getInstance()
+    inst.onNewMessage = (data) => {
+      console.log('im-push', data)
+      this.listeners.forEach((l) => {
+        l(data)
+      })
+    }
+  }
+}
+
+export default new ImPush()

package/src/util/request.js

@@ -0,0 +1,227 @@
+import axios from 'axios'
+import queryString from 'query-string'
+import { isFunction } from './type'
+
+const STATUS = {
+  pending: 1,
+  finish: 2,
+  error: 3
+}
+
+export default class Request {
+  static create(config) {
+    const cache = {}
+    const _config = {
+      withCredentials: false,
+      loadingTime: 1500,
+      shouldBlock(error) {
+        const status = error?.response?.status
+        return status === 429 || status === 503
+      },
+      block(_c) {
+        return true
+      },
+      blockTime: 10 * 60 * 1000,
+      shouldRetry(error) {
+        return error?.response?.status >= 500
+      },
+      ...config
+    }
+    const instance = axios.create(_config)
+
+    const originRequest = instance.request.bind(instance)
+    let blockRequest = false
+    let blockError = null
+
+    const handleError = (error, c) => {
+      // failover 对于一个请求只允许进行一次
+      if (isFunction(c.failover)) {
+        const newConfig = c.failover(error, c)
+        if (typeof newConfig === 'object') {
+          return instance.request({
+            ...newConfig,
+            failover: false
+          })
+        }
+      }
+
+      if (isFunction(c.shouldBlock)) {
+        blockRequest = c.shouldBlock(error)
+        blockError = error
+        setTimeout(() => {
+          blockRequest = false
+          blockError = null
+        }, c.blockTime)
+      }
+
+      if (c.retry > 0 && c._retry < Math.min(c.retry, 2)) {
+        if (c.shouldRetry(error)) {
+          c._retry += 1
+          return instance.request(c)
+        }
+      }
+      if (isFunction(c.error)) {
+        c.error(error, c)
+      }
+      return Promise.reject(error)
+    }
+
+    const getKey = ({ key, params, url }) => {
+      if (key) {
+        return key
+      }
+      const query = queryString.stringify(params)
+      const _key = `${url}${query ?? `?${query}`}`
+      return _key
+    }
+
+    const clearLoadingTimer = (key) => {
+      if (cache[key]) {
+        const { timer } = cache[key]
+        if (timer) {
+          clearTimeout(timer)
+        }
+      }
+    }
+
+    instance.request = function request(c) {
+      const key = getKey(c)
+      c.key = key
+      const exist = cache[key]
+      if (exist) {
+        // get 请求支持缓存
+        if (c.method === 'get') {
+          // 同 url 请求还在等待的直接返回，不发起请求
+          if (exist.status === STATUS.pending) {
+            return cache[key]._request
+          }
+          // 强制请求，直接发起，忽略缓存情况
+          if (c.force) {
+            return originRequest(c)
+          }
+          // 存在缓存数据，直接使用
+          if (cache[key].response) {
+            return Promise.resolve(cache[key].response)
+          }
+        }
+      } else {
+        const { loading = _config.loading, loadingTime = _config.loadingTime } = c
+        cache[key] = {
+          status: STATUS.pending,
+          timer: setTimeout(() => {
+            if (isFunction(loading)) {
+              loading({
+                ...c,
+                key
+              })
+            }
+          }, loadingTime)
+        }
+      }
+
+      const req = originRequest(c)
+      cache[key]._request = req
+      return req
+    }
+
+    {
+      const actions = ['delete', 'get', 'head', 'options']
+      actions.forEach((method) => {
+        instance[method] = function request(url, c) {
+          return instance.request({
+            ...c,
+            method,
+            url,
+            data: (c || {}).data
+          })
+        }
+      })
+    }
+
+    {
+      const actions = ['post', 'put', 'patch']
+      actions.forEach((method) => {
+        instance[method] = function request(url, data, c) {
+          return instance.request({
+            ...c,
+            method,
+            url,
+            data
+          })
+        }
+      })
+    }
+
+    instance.interceptors.request.use(
+      (c) => {
+        if (blockRequest && c.block(c)) {
+          return Promise.reject(blockError)
+        }
+        c._retry = c._retry ?? 0
+        return c
+      },
+      (error) => handleError(error, error.config)
+    )
+
+    instance.interceptors.response.use(
+      (response) => {
+        const c = response.config
+        const { ttl, method, key } = c
+        if (key) {
+          clearLoadingTimer(key)
+          if (cache[key]) {
+            cache[key].status = STATUS.finish
+
+            if (method.toLocaleLowerCase() === 'get' && ttl > 0) {
+              cache[key].response = response
+              if (cache[key].clearCacheTimer) {
+                clearTimeout(cache[key].clearCacheTimer)
+              }
+              cache[key].clearCacheTimer = setTimeout(() => {
+                delete cache[key]
+              }, ttl)
+            } else {
+              delete cache[key]
+            }
+          }
+        }
+        if (isFunction(_config.complete)) {
+          _config.complete(c)
+        }
+        return response
+      },
+      (error) => {
+        const { key } = error.config
+        if (key) {
+          clearLoadingTimer(key)
+          if (cache[key]) {
+            cache[key].status = STATUS.error
+            delete cache[key]
+          }
+        }
+        if (isFunction(_config.complete)) {
+          _config.complete(error.config)
+        }
+        return handleError(error, error.config)
+      }
+    )
+
+    instance.clear = function clear(url) {
+      if (url) {
+        const item = cache[url]
+        if (item && item.status !== STATUS.pending) {
+          delete cache[url]
+        }
+      } else {
+        Object.keys(cache).forEach((key) => {
+          const item = cache[key]
+          if (item && item.status !== STATUS.pending) {
+            delete cache[key]
+          }
+        })
+      }
+    }
+
+    return instance
+  }
+}

package/src/util/type.js

@@ -0,0 +1,17 @@
+export function isFunction(v) {
+  return typeof v === 'function'
+}
+
+export function isIE() {
+  return /msie|trident/.test(window.navigator.userAgent.toLowerCase())
+}
+
+export function isWin7() {
+  return navigator.userAgent.indexOf('Windows NT 6.1') >= 0
+}
+
+export function isH5() {
+  return window.navigator.userAgent.match(
+    /(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i
+  )
+}