@polyv/utils 1.6.0 → 2.0.0-beta.2

package/src/countdown.js

@@ -1,91 +0,0 @@
-/**
- * 本模块提供倒数功能。
- * @module countdown
- */
-
-const computes = [
-  { divisor: 24 * 60 * 60 * 1000, unit: 'days' },
-  { divisor: 60 * 60 * 1000, unit: 'hours' },
-  { divisor: 60 * 1000, unit: 'minutes' },
-  { divisor: 1000, unit: 'seconds' }
-];
-
-/**
- * 倒计时回调函数。
- * @callback countdownCallback
- * @memberof module:countdown.Countdown
- * @param {Object} rest 剩余的时间。
- *   @param {number} rest.days 剩余天数。
- *   @param {number} rest.hours 剩余小时数。
- *   @param {number} rest.minutes 剩余分钟数。
- *   @param {number} rest.seconds 剩余秒数。
- *   @param {boolean} rest.totalMsecs 剩余的总毫秒数。
- */
-/**
- * 倒计时类。
- * @memberof module:countdown
- * @class
- * @name Countdown
- * @author luoliquan
- * @param {number} secs 总秒数。
- * @param {countdownCallback} [cb] 回调函数。
- * @example
- * const countdown = new Countdown(60, (rest) => {
- *   console.dir(rest);
- * });
- * countdown.start();
- */
-export default class Countdown {
-  constructor(secs, cb) {
-    secs = parseInt(secs);
-    if (isNaN(secs)) { throw new Error('Total seconds must be a number'); }
-    this._secs = secs * 1000; // 倒计时毫秒数
-    this._cb = typeof cb === 'function' ? cb : function() {}; // 倒计时回调函数
-  }
-
-  _exec() {
-    if (!this._startTime) { return; }
-
-    let value = Math.max(0, this._secs - (Date.now() - this._startTime));
-    if (value > 0 && !this._stopped) {
-      setTimeout(() => { this._exec(); }, 1000);
-    }
-
-    if (value >= 0) {
-      const rest = {
-        totalMsecs: value
-      };
-      computes.forEach((item, i) => {
-        rest[item.unit] = value / item.divisor;
-        if (i === computes.length - 1) {
-          rest[item.unit] = Math.round(rest[item.unit]);
-        } else {
-          rest[item.unit] = Math.floor(rest[item.unit]);
-          value = value % item.divisor;
-        }
-      });
-      this._cb(rest);
-    }
-  }
-
-  /**
-   * 开始倒计时。
-   * @method
-   * @memberof module:countdown.Countdown.prototype
-   */
-  start() {
-    if (this.secs <= 0) { return; }
-    this._startTime = Date.now();
-    this._exec();
-  }
-
-  /**
-   * 停止倒计时。
-   * @method
-   * @memberof module:countdown.Countdown.prototype
-   */
-  stop() {
-    if (this._timerId) { clearTimeout(this._timerId); }
-    this._stopped = true;
-  }
-}

package/src/date.js

@@ -1,92 +0,0 @@
-/**
- * 本模块提供日期处理相关方法。
- * @module date
- */
-
-import { extend } from './lang';
-
-// 保证日期相关函数的操作对象为日期类型
-export function ensureDate(date) {
-  if (typeof date !== 'object') { date = new Date(date); }
-  return date;
-}
-
-/**
- * 格式化日期。
- * @author luoliquan
- * @param {(Date|number)} date 日期对象或时间戳（毫秒）。
- * @param {string} formation 格式。
- * @return {string} 格式化结果。
- * @example
- * formatDate(new Date(2018, 9, 8, 8, 50, 56), 'YYYY-MM-DD hh:mm:ss'); // '2018-10-08 08:50:56'
- */
-export function formatDate(date, formation) {
-  date = ensureDate(date);
-
-  const values = {
-    Y: date.getFullYear(),
-    M: date.getMonth() + 1,
-    D: date.getDate(),
-    h: date.getHours(),
-    m: date.getMinutes(),
-    s: date.getSeconds()
-  };
-
-  return formation.replace(/([YMDhms])\1*/g, (match) => {
-    let result = values[match[0]];
-    if (match.length > 1 && result.toString().length !== match.length) {
-      result = ((new Array(match.length)).join('0') + result).slice(-match.length);
-    }
-    return result;
-  });
-}
-
-/**
- * 把秒数格式化成「时:分:秒」格式。
- * @author luoliquan
- * @param {number} secs 秒数。
- * @param {Object} [options] 格式化配置。
- *   @param {number} [options.segments=2] 段数，2 或者 3。
- *     为 2 时，如果小时为 0，则格式化样式为「分:秒」。
- *   @param {number} [options.digits=2] 每一段数字的最小位数，不足位数时补 0。
- * @return {string} 格式化结果。
- * @example
- * formatSeconds(3682); // '01:01:22'
- * formatSeconds(82); // '01:22'
- * formatSeconds(82, { segments: 3 }); // '00:01:22'
- * formatSeconds(3682, { digits: 1 }); // '1:1:22'
- */
-export function formatSeconds(secs, options) {
-  secs = Number(secs);
-  if (isNaN(secs) || secs < 0) {
-    throw new Error('"secs" must be a positive integer');
-  }
-
-  // 参数合法性校验
-  options = extend({}, options);
-  options.segments = parseInt(options.segments);
-  // 位数最小为 1
-  options.digits = Math.max(1, parseInt(options.digits) || 2);
-  // 段数只能为 2 或者 3
-  if ([2, 3].indexOf(options.segments) === -1) {
-    options.segments = 2;
-  }
-
-  // 需要补多少个 0
-  const zeros = (new Array(options.digits + 1).join('0'));
-
-  const result = [
-    60 * 60,
-    60,
-    1
-  ].map((num) => {
-    const subResult = Math.floor(secs / num);
-    const len = subResult.toString().length;
-    secs = secs % num;
-    return (zeros + subResult).slice(-Math.max(len, options.digits));
-  });
-
-  if (options.segments < 3 && !Number(result[0])) { result.shift(); }
-
-  return result.join(':');
-}

package/src/internal/core.js

@@ -1,59 +0,0 @@
-/**
- * @module internal-core
- * @ignore
- */
-
-// ESLint 不推荐直接使用 obj.hasOwnProperty
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-/**
- * 检查指定对象是否具有某个 own property。
- * @function
- * @name hasOwnProp
- * @author luoliquan
- * @param {Any} obj 指定对象。
- * @param {string} prop 属性名。
- * @return {boolean} 指定对象是否具有某个 own property。
- */
-export function hasOwnProp(obj, prop) {
-  return hasOwnProperty.call(obj, prop);
-}
-
-// 单个源扩展
-export function extendSingle(target, src) {
-  if (src != null) {
-    let key, value;
-    for (key in src) {
-      value = src[key];
-      if (key === '__proto__' || target === value) { continue; }
-      if (hasOwnProp(src, key)) { target[key] = value; }
-    }
-  }
-}
-
-
-const toString = Object.prototype.toString;
-
-// 是否 Object 类型
-export function isObject(value) {
-  return toString.call(value) === '[object Object]';
-}
-
-// 是否 Date 类型
-export function isDate(value) {
-  return toString.call(value) === '[object Date]';
-}
-
-
-/**
- * 全局对象，浏览器环境下为 window，Node 环境下为 global。
- * @type {Object}
- */
-let theGlobal;
-if (typeof window !== 'undefined') {
-  theGlobal = window;
-} else if (typeof global !== 'undefined') {
-  theGlobal = global;
-} else {
-  theGlobal = null;
-}
-export { theGlobal };

package/src/internal/timeunit.js

@@ -1,63 +0,0 @@
-/**
- * @module
- * @ignore
- */
-
-import { hasOwnProp } from './core';
-
-// 时间单位
-const timeUnits = {
-  SEC: 1000,
-  MIN: 60 * 1000,
-  HOUR: 60 * 60 * 1000,
-  DAY: 24 * 60 * 60 * 1000,
-  MONTH: 30 * 24 * 60 * 60 * 1000,
-  YEAR: 365 * 24 * 60 * 60 * 1000
-};
-
-/**
- * 把带单位的时间跨度转换为毫秒表示。
- * @author luoliquan
- * @param {(number|string)} timespan 时间跨度。为数字时表示毫秒，为字符串时支持以下格式（%表示数字）：
- *   %secs；
- *   %mins；
- *   %hours；
- *   %days；
- *   %months；
- *   %years。
- * @return {number} 时间跨度的毫秒表示。
- */
-export function parse(timespan) {
-  // str为数字，直接返回
-  if (typeof timespan === 'number') { return timespan; }
-  if (!isNaN(timespan)) { return Number(timespan); }
-
-  const num = parseFloat(timespan);
-  if (isNaN(num)) {
-    throw new Error('Invalid timespan string');
-  }
-
-  const unit = timespan.split(num)[1]
-    .trim()
-    .toUpperCase()
-    .replace(/S$/, ''); // 移除复数时的s
-
-  if (hasOwnProp(timeUnits, unit)) {
-    return num * timeUnits[unit];
-  } else {
-    throw new Error('Invalid time unit "' + unit + '"');
-  }
-}
-
-/**
- * 以指定日期对象的毫秒表示加上指定时间跨度的毫秒表示，生成新的日期对象。
- * @author luoliquan
- * @param {(Date|number)} date 指定日期对象或日期的毫秒表示。
- * @param {(number|string)} timespan 时间跨度，为数字时表示毫秒，为字符串时支持的格式同 parse。
- * @return {Date} 表示相加结果的日期对象。
- */
-export function addToDate(date, timespan) {
-  return new Date(
-    (typeof date === 'number' ? date : date.getTime()) + parse(timespan)
-  );
-}

package/src/lang.js

@@ -1,121 +0,0 @@
-/**
- * 本模块提供基础方法。
- * @module lang
- */
-
-import { extendSingle, hasOwnProp, isObject } from './internal/core';
-
-/**
- * 检查指定对象是否具有某个 own property（ESLint 不推荐直接使用 obj.hasOwnProperty）。
- * @author luoliquan
- * @name hasOwnProp
- * @function
- * @static
- * @param {Any} obj 指定对象。
- * @param {string} prop 属性名。
- * @return {boolean} 指定对象是否具有某个 own property。
- */
-export { hasOwnProp };
-
-/**
- * 检查指定对象是否为类数组结构。
- * @author luoliquan
- * @param {Any} obj 指定对象。
- * @return {boolean} 检查指定对象是否为类数组结构。
- * @example
- * isArrayLike([]); // true
- * isArrayLike(document.getElementsByTagName('body')); // true
- * isArrayLike({}); // false
- */
-export function isArrayLike(obj) {
-  return obj != null &&
-    typeof obj !== 'function' &&
-    typeof obj.length === 'number' &&
-    obj.length >= 0 &&
-    obj.length % 1 === 0; // 不是小数
-}
-
-/**
- * 检查指定值是否为空数据。以下情况会判断为空数据：
- *   null 或者 undefined；
- *   数组结构，但长度为 0；
- *   空字符串或仅包含空白字符的字符串；
- *   没有 own property 的纯对象。
- * @author luoliquan
- * @param {Any} value 指定值。
- * @return {boolean} 指定值是否为空数据。
- * @example
- * isEmptyData(null); // true
- * isEmptyData([]); // true
- * isEmptyData(''); // true
- * isEmptyData({}); // true
- * isEmptyData({ a: 1 }); // false
- * isEmptyData([1]); // false
- */
-export function isEmptyData(value) {
-  if (value == null) { return true; }
-  if (typeof value === 'string') {
-    return value.trim() === '';
-  } else if (Array.isArray(value)) {
-    return !value.length;
-  } else if (isObject(value)) {
-    for (const key in value) {
-      if (hasOwnProp(value, key)) { return false; }
-    }
-    return true;
-  }
-  return false;
-}
-
-/**
- * 把源对象的属性（own property）扩展到目标对象（同 Object.assign）。
- * @author luoliquan
- * @param {Any} target 目标对象。
- * @param {...Any} [source] 源对象。若有同名属性，则后者覆盖前者。
- * @return {Any} 目标对象。
- */
-export function extend(target) {
-  if (target == null) {
-    throw new Error('The target argument cannot be null or undefined');
-  }
-
-  const len = arguments.length;
-  let i = 0;
-  while (++i < len) {
-    extendSingle(target, arguments[i]);
-  }
-  return target;
-}
-
-/**
- * 深度克隆指定对象（仅限 JSON 支持的数据类型）。
- * @author liumin
- * @param {Any} obj 指定对象。
- * @return {Any} 克隆结果。
- * @example
- * cloneJSON({ a: 1, b: 2 }); // { a: 1, b: 2 }
- */
-export function cloneJSON(obj) {
-  if (obj == null) { return obj; }
-  return JSON.parse(JSON.stringify(obj));
-}
-
-/**
- * 尝试把指定字符串解析为 JSON 对象。
- * @author luoliquan
- * @param {string} str 指定字符串。
- * @param {Function} [onError] 解析出错时执行的函数。
- * @return {Any} 解析结果，解析失败时返回 undefined。
- * @example
- * tryParseJSON('ss&&**'); // undefined
- * tryParseJSON('{"a": 1}'); // { a: 1 }
- */
-export function tryParseJSON(str, onError) {
-  let result;
-  try {
-    result = JSON.parse(str);
-  } catch (e) {
-    if (onError) { onError(e); }
-  }
-  return result;
-}

package/src/net.js

@@ -1,54 +0,0 @@
-/**
- * 本模块提供网络协议相关方法。
- * @module net
- */
-
-// 匹配协议
-const reProtocol = /^(?:([a-z]+):)?\/{2,3}/i;
-
-/**
- * 检查目标字符串是否以特定 URL 协议开头。
- * @author luoliquan
- * @param {string} str 目标字符串。
- * @param {Array} [protocols] 特定协议（不含冒号和斜杠），不指定时表示允许任何协议。
- * @return {boolean} 目标字符串是否以特定 URL 协议开头。
- * @example
- * startsWithProtocol('//abc.com'); // true
- * startsWithProtocol('https://abc.com'); // true
- * startsWithProtocol('file:///Users/'); // true
- * startsWithProtocol('abc.com'); // false
- * startsWithProtocol('http://abc.com', ['http', 'https']); // true
- * startsWithProtocol('ftp://abc.com', ['http', 'https']); // false
- */
-export function startsWithProtocol(str, protocols) {
-  const result = reProtocol.test(str);
-  if (result && protocols) {
-    const protocol = (RegExp.$1 || '').toLowerCase();
-    for (let i = protocols.length - 1; i >= 0; i--) {
-      if (protocol === protocols[i].toLowerCase()) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return result;
-}
-
-/**
- * 替换目标字符串中的 URL 协议。如果字符串中不包含协议，则加上协议。
- * @author luoliquan
- * @param {string} url 目标字符串。
- * @param {string} protocol 协议。
- * @return {string} 替换结果。
- * @example
- * changeProtocol('abc.com', 'https'); // 'https://abc.com'
- * changeProtocol('http://abc.com', 'https'); // 'https://abc.com'
- */
-export function changeProtocol(url, protocol) {
-  if (!reProtocol.test(protocol)) {
-    protocol += '://';
-  }
-  return startsWithProtocol(url) ?
-    url.replace(reProtocol, protocol) :
-    protocol + url;
-}

package/src/polling.js

@@ -1,142 +0,0 @@
-/**
- * 本模块提供轮询功能。
- * @module polling
- */
-
-import { theGlobal } from './internal/core';
-import { extend } from './lang';
-
-/**
- * 轮询类。
- * @memberof module:polling
- * @class
- * @name Polling
- * @constructor
- * @param {Function} executor 执行函数，返回值为 Promise（带有 then 方法）时会进行异步处理。
- * @param {Object} [options] 其他选项。
- *   @param {number} [options.interval=1000] 轮询间隔（毫秒）。
- *   @param {boolean} [options.breakOnError=false] 执行函数有异常（包括 Promise 的拒绝状态）时是否中断轮询。
- * @example
- * const polling = new Polling(() => {
- *   return new Promise((resolve) => {
- *     setTimeout(() => {
- *       console.log('executed');
- *       resolve();
- *     }, 1000);
- *   });
- * }, {
- *   interval: 2000
- * });
- * polling.start();
- */
-export default class Polling {
-  constructor(executor, options) {
-    // 执行函数
-    this._executor = executor;
-    // 其他选项
-    this._options = extend({
-      interval: 1000,
-      breakOnError: false
-    }, options);
-    // 轮询计时器 id
-    this._timerId = null;
-    // 轮询是否已开始
-    this._started = false;
-    // 是否正在运行执行函数（针对异步情况）
-    this._isExecuting = false;
-    // 是否要在当前轮询之后马上运行执行函数
-    this._shouldImmediate = false;
-  }
-
-  // 执行轮询函数
-  _exec() {
-    let result;
-    try {
-      result = this._executor.call(theGlobal);
-    } catch (e) {
-      if (this._options.breakOnError) {
-        this.stop();
-      }
-    }
-
-    if (result && typeof result.then === 'function') {
-      // 异步情况，在 Promise 回调中继续下一次轮询
-      this._isExecuting = true;
-      result.then(() => {
-        this._isExecuting = false;
-        this._next();
-      }, () => {
-        this._isExecuting = false;
-        if (this._options.breakOnError) {
-          this.stop();
-        } else {
-          this._next();
-        }
-      });
-
-    } else {
-      // 同步情况，直接执行下一次轮询
-      this._next();
-    }
-  }
-
-  // 下一次轮询
-  _next() {
-    if (this._shouldImmediate) {
-      // 外部调用了 execImmediately，马上执行
-      this._exec();
-
-    } else if (this._started) {
-      // 进入下一次轮询
-      this._timerId = setTimeout(() => {
-        this._exec();
-      }, this._options.interval);
-    }
-  }
-
-  /**
-   * 在当前轮询结束后马上执行一次执行函数。
-   * @method
-   * @memberof module:polling.Polling.prototype
-   */
-  execImmediately() {
-    // 阻止下次轮询
-    this._clearTimeout();
-
-    if (this._isExecuting) {
-      // 如果当前轮询还在运行中，先记录下来，待结束后再执行
-      this._shouldImmediate = true;
-    } else {
-      // 下一次轮询还没开始，直接运行执行函数
-      this._exec();
-    }
-  }
-
-  /**
-   * 启动轮询。
-   * @method
-   * @memberof module:polling.Polling.prototype
-   */
-  start() {
-    this._started = true;
-    this._exec();
-  }
-
-  /**
-   * 停止轮询。
-   * @method
-   * @memberof module:polling.Polling.prototype
-   */
-  stop() {
-    this._clearTimeout();
-    this._started = false;
-  }
-
-  // 清理计时器
-  _clearTimeout() {
-    if (this._timerId) {
-      clearTimeout(this._timerId);
-      this._timerId = null;
-    }
-  }
-}