export function co(gen: any) {
  let destroyed = false;

  // 处理 return 之后 resume 的问题
  let stop = false;

  let val: any = null;

  if (typeof gen === "function") gen = gen();

  if (!gen || typeof gen.next !== "function") return () => ({});

  Promise.resolve().then(() => {
    destroyed || next(gen.next());
  });

  return {
    end() {
      destroyed = true;

      Promise.resolve().then(() => {
        gen.return();

        gen = null;
      });
    },
    pause() {
      if (!destroyed) {
        stop = true;
      }
    },
    resume() {
      const oldVal = val;

      if (!destroyed && stop) {
        stop = false;

        Promise.resolve(val).then(function () {
          if (!destroyed && !stop && oldVal === val) {
            next(gen.next());
          }
        });
      }
    },
  };

  function next(ret: any) {
    if (ret.done) return ret.value;

    val = ret.value;

    return Promise.resolve(ret.value).then(() => {
      !destroyed && !stop && next(gen.next());
    });
  }
}

/**
 * @description                       将函数转成防抖动函数
 * @param  {Function}                 需要转成防抖动函数的函数
 * @param  {number}                   延迟时间（毫秒数）
 * @param  {boolean}                  是否执行第一次
 * @return {undefined}                无返回值
 */
export function debounce(fn: any, delay = 600, runFirstFn = true) {
  let timer: any = null;

  return function (this: any, ...rest: any) {
    // 清除定时器
    clearTimeout(timer);
    if (runFirstFn) {
      fn.apply(this, rest);
      runFirstFn = false;
      return;
    }

    // 设置定时器
    timer = setTimeout(fn.bind(this, ...rest), delay);
  };
}
export function observerDomResize(dom: any, callback: any) {
  const MutationObserver = window.MutationObserver;
  // window.WebKitMutationObserver ||
  // window.MozMutationObserver;

  const observer = new MutationObserver(callback);

  observer.observe(dom, {
    attributes: true,
    attributeFilter: ["style"],
    attributeOldValue: true,
  });
  return observer;
}
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _util = require("./../util/utils");
export function deepMerge(target: any, merged: any) {
  for (var key in merged) {
    if (target[key] && _typeof2["default"](target[key]) === "object") {
      deepMerge(target[key], merged[key]);
      continue;
    }

    if (_typeof2["default"](merged[key]) === "object") {
      target[key] = _util.deepClone(merged[key], true);
      continue;
    }

    target[key] = merged[key];
  }

  return target;
}