const useMount = (cb) => {
  useEffect(cb, [])
}

const useUpdate = (cb, deps) => {
  const ref = useRef(0)
  useEffect(() => {
    if (ref.current) {
      cb()
    }
    ref.current = ref.current + 1
  }, deps)
}

const useUnmout = (cb) => {
  useEffect(() => {
    return cb
  }, [])
}

/**
 * 排列问题可以简化为每次从数组中提取出一个元素
 * 边界处理
 *  1. 当只需要一个元素时返回这个元素的二维数组
 *  2. 其它每次提取一个元素放到数组中即可
 */

function getData(arr, restLen) {
  if (arr.length < restLen) {
    return []
  }
  let result = []
  for (let i = 0; i < arr.length; i++) {
    const tempArr = arr.filter((ele, index) => i !== index)
    let list = []
    if (restLen <= 1) {
      list = [[arr[i]]]
    } else {
      list = getData(tempArr, restLen - 1).map((item) => [arr[i], ...item])
    }

    result = [...result, ...list]
  }
  return result
}

const arr = [1, 2, 3, 4]
let list = []
for (let i = 1; i <= arr.length; i++) {
  list = [...list, ...getData(arr, i)]
}

console.log('list', list, list.length)

function traverseDirectory(pathname) {
  const realPath = resolveRootPath(pathname)
  if (isDirectory(realPath)) {
    const result = []
    const list = fs.readdirSync(realPath)
    const len = list.length
    for (let i = 0; i < len; i++) {
      const tempPath = path.resolve(pathname, list[i])
      if (isDirectory(list[i])) {
        const tempArr = traverseDirectory(tempPath)
        result.push(...tempArr)
      } else {
        result.push(tempPath)
      }
    }
    return result
  } else {
    return []
  }
}

async function getProjectConfig(pathname) {
  const defaultProjectName = (pathname || process.cwd())
    .split(/(\/|\\)/)
    .reverse()
    .filter(Boolean)[0]

  const answers = await inquirer.prompt([
    {
      name: 'name',
      message: '请输入项目名称',
      default: defaultProjectName,
    },
    {
      name: 'version',
      message: '请输入版本',
      default: '1.0.0',
    },
    {
      name: 'author',
      message: '请输入创建人',
    },
    {
      name: 'template',
      message: '请选择模板',
      type: 'list',
      choices: Object.keys(templateMap).map((key) => ({
        key,
        value: key,
        name: templateMap[key].label,
      })),
    },
  ])
  return answers
}

async function getTemplate(key) {
  const temp = templateMap[key]
  if (temp && temp.isGit) {
    try {
      rm(downloadTempRootPath)
      const target = await downloadTemplate(temp.path, downloadTempRootPath, {
        clone: true,
      })
      return target
    } catch (e) {
      error('\ngit 拉取模板失败，失败原因：', e)
      return ''
    }
  }
  return temp.path
}

async function generateProject(source, destination, config) {
  return new Promise((resolve, reject) => {
    metalsmith(process.cwd())
      .metadata(config)
      .clean(false)
      .source(source)
      .destination(destination)
      .use((files, metalsmith, done) => {
        const meta = metalsmith.metadata()
        Object.keys(files).forEach((fileName) => {
          const t = files[fileName].contents.toString()
          files[fileName].contents = Buffer.from(Handlebars.compile(t)(meta))
        })
        done()
      })
      .build((err) => {
        rm(process.cwd())
        if (err) {
          reject(err)
        } else {
          resolve()
        }
      })
  })
}

const ob = new IntersectionObserver(callback, options)

ob.observe(targetElement)

ob.unobserve(target)

ob.disconnect()

require("child_process").exec("cmd");

const { stdout, stderr } = require("util").promisify(
  require("child_process").exec
)("cmd");

const { stdout, stderr } = await require("util").promisify(
  require("child_process").exec
)(`lsof -i tcp:8080`);

const list = stdout
  .toLowerCase()
  .split("\n")
  .filter(Boolean)
  .filter((str) => /^node/.test(str))
  .map((str) => {
    const reg = /^node\s+(\w+)\s+/.exec(str);
    return Number(reg[1]);
  });

const { stdout, stderr } = await require("util").promisify(
  require("child_process").exec
)(`kill 45971`);

const { exec } = require("child_process");
const util = require("util");

const { log, error, info } = require("./utils");

const pExec = util.promisify(exec);

async function getPid(port) {
  try {
    const { stdout, stderr } = await pExec(`lsof -i tcp:${port}`);
    if (stderr) {
      throw new Error(stderr);
    } else {
      const list = stdout
        .toLowerCase()
        .split("\n")
        .filter(Boolean)
        .filter((str) => /^node/.test(str))
        .map((str) => {
          log(str);
          const reg = /^node\s+(\w+)\s+/.exec(str);
          return Number(reg[1]);
        });
      return list;
    }
  } catch (e) {
    error(e);
    return [];
  }
}

async function kill(pid) {
  try {
    const { stdout, stderr } = await pExec(`kill ${pid}`);
    if (stderr) {
      throw new Error(stderr);
    } else {
      if (stdout) {
        log(stdout);
      }
      info(`kill pid ${pid} success`);
    }
  } catch (e) {
    error(e);
  }
}

async function init(port) {
  const pids = await getPid(port);
  try {
    await Promise.all(pids.map((pid) => kill(pid)));
    process.exit(0);
  } catch (e) {
    error(e);
    process.exit(1);
  }
}

init(8080);

const hjson = require("hjson");
const fs = require("fs");
const path = require("path");

const text = fs.readFileSync("./tsconfig.json", { encoding: "utf8" });

const tsConfig = hjson.parse(text);

const pathMap = tsConfig.compilerOptions.paths || {};
const pathAlias = Object.keys(pathMap).reduce((prev, curr) => {
  const realKey = `${curr}`.replace(/\/\*$/, "");
  const realPath = `/${(pathMap[curr] || [])[0]}`
    .replace(/\/\*$/, "")
    .replace(/^\S*src/, "./dist");
  prev[realKey] = realPath;
  return prev;
}, {});

module.exports = function (api) {
  api.cache(true);

  const plugins = [
    [
      "module-resolver",
      {
        root: ["dist/"],
        alias: pathAlias,
      },
    ],
  ];

  return {
    plugins,
  };
};

src // 源码目录
|--- utils // 工具文件目录
|   |--- log.ts // 输出日志文件
|   |--- env.ts // 环境参数相关
|--- index.ts // 项目入口文件
|--- babel.config.js // babel 相关配置
|--- nodemon.json // nodemon 相关配置
|--- package.json // 项目配置
|--- tsconfig.json // ts 相关配置

const x = window.screenLeft || window.screenX;
const y = window.screenTop || window.screenY;

// 函数声明
func(); // 函数声明提升，输出结果 func
function func(...args) {
  console.log(func.name); // func
}

// 函数表达式
func(); //  无提升，抛出异常 TypeError: func is not a function
var func = function (...args) {
  console.log(func.name); // func
};

function func(...args) {
  console.log(arguments.callee.name); // func
}

var arr = [];
function test() {
  for (var i = 0; i < 4; i++) {
    arr[i] = function () {
      console.log(i);
    };
  }
}
test();
arr[2](); // 4

// 立即执行函数强制进行值传递
var arr = [];
function test() {
  for (var i = 0; i < 4; i++) {
    arr[i] = (function (j) {
      return function () {
        console.log(j);
      };
    })(i);
  }
}
test();
arr[2](); // 2

var name = "window";
var test = {
  name: "test",
  getName: function () {
    // 存在活动对象，搜索到这里为止
    return function () {
      // 匿名函数执行环境具有全局性
      console.log(this.name); // window
    };
  },
};

test.getName()();

(function () {
  let test = name; // 静态私有变量
  return function Sup(name) {
    this.prototype.getName = function () {
      return test;
    };

    this.prototype.setName = function (temp) {
      test = temp;
    };
  };
})();

const app = (function () {
  const arr = [];
  return {
    getCount: function () {
      return arr.length;
    },
    addComp: function (comp) {
      arr.push(comp);
    },
  };
})();

const app = (function () {
  const obj = new Object(); // 实例对象
  let len = 10;
  obj.getCount = function () {
    return len;
  };
  return obj;
})();