Promise.all([promise1, promise2])
所有promise都fulfilled才会resolve，返回对应的promise结果的数组，否则reject第一个rejected的promise的数据.

Promise.allSettled([promise1, promise2])
所有promise状态变化后resolve，返回对应的promise结果的数组。

Promise.race([promise1, promise2]) 
只要有一个promise状态改变，就返回对应promise结果

  (1)
  const a = {}
  console.log(a.b?.c) // undefined
  a.b?.()  // undefined
 
  在属性或者函数执行上，可避免报错，通过undefined检测属性和函数是否存在。
 
 （2）当使用方括号与属性名的形式来访问属性时，你也可以使用可选链操作符；可以用来访问数组；可选链不能赋值；
 let nestedProp = obj?.['prop' + 'Name'];
 const = arr?.[42];
 
 （3）连用可选链操作符
  可以连续使用可选链读取多层嵌套结构：
  console.log(a?.b?.c?.d?.f) // undefined
  
  (4)另有 Nullish coalescing 空值合并操作符 ??
   - 空值合并操作符（??）是一个逻辑操作符，当左侧的操作数为 null 或者 undefined 时，返回其右侧操作数，否则返回左侧操作数。
   - 与 || 不同，当为''或0时，也会触发，但是??只在null或者undefined触发。
   - 空值合并操作符可以在使用可选链时设置一个默认值。空值合并操作符针对 undefined 与 null 这两个值，可选链式操作符（?.） 也是如此。
   - 在这访问属性可能为 undefined 与 null 的对象时，可选链式操作符非常有用。
   
   console.log(a?.b?.c ?? 'hello')
   

try catch 内的代码无法被V8编译优化， 最好是提出来作为一个单独函数。
const run = () => {}
try{
   run();
} catch(){}

webpack-chain 是一个链式API用于创建和修改webpack配置。

// chain就是webpack-chain实例对象

chain.module
            .rule('cdnLoader')
            .test(/\.(.+)$/i) // 匹配public文件夹下任意文件
            .include.add(resolve('public')) // 必须限制只针对与src同级的public生效
            .end()
            .use('url-loader')
            .loader('url-loader')
            .options({
              limit: true, // 强制使用generator
              generator: (content, mimetype, encoding, resourcePath) => {
                const isProd = process.env.NODE_ENV === 'production'
                const relativePath = relative(resolve('public'), resourcePath)
                // 相对路径，如 /public/dir/test1.jpg 结果是 'dir/test1.jpg'
                console.log({
                  relativePath,
                  mimetype,
                  encoding,
                  resourcePath,
                  isProd,
                }) // 打包期间可以看到日志，表示执行成功
                const cdnHost =
                  process.env.CUSTOM_PUBLIC_CDN_HOST
                return isProd
                  ? cdnHost + '/' + relativePath
                  : `data:${mimetype}${
                      encoding ? `;${encoding}` : ''
                    },${content.toString(encoding)}`
                // 调试时，一律使用base64，build时NODE_ENV=production，则使用链接
              },
            })
            .end()
            .enforce('post') // 强制最后执行

[1,2,3,4].some(p => {
	console.log(p)
	return p > 1
})
// 1
// 2
// true

    一致性Hash是一种特殊的Hash算法，由于其均衡性、持久性的映射特点，广泛应用于负载均
衡领域，如nginx和memcached都采用了一致性Hash作为集群负载均衡的方案。
    先构造一个长度为2^32的整数环（这个环被称为一致性Hash环），根据节点名称的Hash值
（其分布为[0, 2^32-1]）将服务器节点放置在这个Hash环上，然后根据数据的Key值计算得到
其Hash值（其分布也为[0, 2^32-1]），接着在Hash环上顺时针查找距离这个Key值的Hash值
最近的服务器节点，完成Key到服务器的映射查找。

import { loader } from 'webpack';
import path from 'path';

export default function svgCheckLoader(this: loader.LoaderContext, content: string): string {
  
  // 可以在this内读取到上下文一些信息
  const { resourcePath = '' } = this
  console.log(resourcePath, svgCheckerData.files.length)
  // 这里转换，然后返回转换后的内容
  return content;
}

import { getOptions } from 'loader-utils';
import { loader } from 'webpack';

function cdnFileLoader(): string {
  return '';
}

function cdnFileLoaderPitch(this: loader.LoaderContext): string {
  const options = getOptions(this);

  const loaderOptions = Object.assign(
    {
      name: '[path][name].[ext]',
      outputPath: '../output',
      publicPath: '/',
      context: process.cwd(),
    },
    options,
  );

  const queryStr = Object.entries(loaderOptions || {})
    .map(([key, value]) => {
      return `${key}=${value}`;
    })
    .join('&');

  const returnContent = `
    import content from '!!file-loader?${queryStr}!${this.resourcePath}';

    export default content;
  `;

  return returnContent;
}

export default cdnFileLoader;

export { cdnFileLoaderPitch as pitch };

/* eslint-disable semi */
import { parse } from '@babel/parser'
import traverse, { NodePath } from '@babel/traverse'

const checkMap = {
  ArrowFunctionExpression: '箭头函数',
  VariableDeclaration: 'const、let变量',
  AwaitExpression: 'await表达式',
  YieldExpression: 'Yield表达式',
  ClassDeclaration: 'class定义',
  AsyncFunction: 'async函数',
  TemplateElement: '模版字符串',
  SpreadElement: '拓展运算符',
  RestElement: 'rest元素',
  ForOfStatement: 'for of遍历方式',
  ObjectMethod: "对象方法, getter, setter",
}

type CheckType = keyof typeof checkMap

interface CheckBin {
  type: CheckType
  name: string
  kind?: string
  code: string
  pos: number
}

interface Options {
  /** 最多统计几个结果 默认3 */
  limit?: number
  /** 代码片段长度限制 默认200 */
  codeFrgmentSize?: number
}

/**
 * 检测es6语法（注意，这边只检测语法，不检测es6新的API，如Set、Map、Promise、Object.assign、Array.from等）
 * 支持如下常用的es6语法：
 * 箭头函数
 * const、let
 * async、await
 * yield表达式
 * class定义
 * 模版字符串
 * ...拓展运算符
 * ...rest参数等rest元素
 * for of遍历方式
 * 对象方法, getter, setter
 *
 */

const esChecker = (code: string, options?: Options): CheckBin[] => {
  const { limit = 3, codeFrgmentSize = 200 } = options || {}

  const result: CheckBin[] = []

  const report = (params: { type: CheckType; kind?: string; n: NodePath }) => {
    if (result.length >= limit) return
    const { type, kind = '', n } = params
    const node = n.node
    const start = node.start
    const end = node.end
    const content =
      typeof start === 'number' && typeof end === 'number'
        ? end - start <= codeFrgmentSize
          ? code.slice(start, end)
          : code.slice(start, start + codeFrgmentSize)
        : ''

    result.push({
      type,
      name: checkMap[type],
      kind,
      code: content,
      pos: typeof start === 'number' ? start : -1,
    })
  }

  const ast = parse(code)

  traverse(ast, {
    ArrowFunctionExpression: (n) => {
      report({ type: 'ArrowFunctionExpression', n })
    },
    VariableDeclaration: (nodePath) => {
      const kind = nodePath.node.kind
      if (kind === 'const' || kind === 'let') {
        report({ type: 'VariableDeclaration', kind, n: nodePath })
      }
    },
    AwaitExpression: (n) => report({ type: 'AwaitExpression', n }),
    YieldExpression: (n) => report({ type: 'YieldExpression', n }),
    ClassDeclaration: (n) => report({ type: 'ClassDeclaration', n }),
    FunctionDeclaration: (nodePath) => {
      const async = nodePath.node.async
      if (async) report({ type: 'AsyncFunction', n: nodePath })
    },
    SpreadElement: (n) => report({ type: 'SpreadElement', n }),
    RestElement: (n) => report({ type: 'RestElement', n }),
    ForOfStatement: (n) => report({ type: 'ForOfStatement', n }),
    TemplateElement: (n) => report({ type: 'TemplateElement', n }),
    ObjectMethod: (n) => {
      const kind = n.node.kind;
      const async = n.node.async;
      report({ type: "ObjectMethod", kind, n });
      if (async) report({ type: "AsyncFunction", n });
    },
  })
  return result
}

/*

https://github.com/babel/babylon/blob/master/ast/spec.md
https://babeljs.io/docs/en/babel-types

  interface VariableDeclaration <: Declaration {
    type: "VariableDeclaration";
    declarations: [ VariableDeclarator ];
    kind: "var" | "let" | "const";
  }

  Expressions:
  interface Super <: Node {
      type: "Super";
  }
  interface ArrowFunctionExpression <: Function, Expression {
    type: "ArrowFunctionExpression";
    body: BlockStatement | Expression;
    expression: boolean;
  }
  interface YieldExpression <: Expression {
    type: "YieldExpression";
    argument: Expression | null;
    delegate: boolean;
  }
  interface AwaitExpression <: Expression {
    type: "AwaitExpression";
    argument: Expression | null;
  }
  interface Function <: Node {
    id: Identifier | null;
    params: [ Pattern ];
    body: BlockStatement;
    generator: boolean;
    async: boolean;
  }

  interface SpreadElement <: Node {
    type: "SpreadElement";
    argument: Expression;
  }
  interface RestElement <: Pattern {
    type: "RestElement";
    argument: Pattern;
  }
  interface Class <: Node {
    id: Identifier | null;
    superClass: Expression | null;
    body: ClassBody;
    decorators: [ Decorator ];
  }
  // es6对象方法语法、getter、setter
  // 即 const p = { get hello() { return 0 } }
  interface ObjectMethod <: ObjectMember, Function {
    type: "ObjectMethod";
    kind: "get" | "set" | "method";
  }

*/

// 调试node, 执行npm命名
// 在项目.vscode文件夹下添加 launch.json 设置如下配置
{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "CLI debug",
      // 这里是项目地址，也就是package.json所在文件夹绝对路径
      "cwd": "/Users/55utah/workspace/reportx12/reportx",
      // 指定执行npm命令
      "runtimeExecutable": "npm",
      // 这里指执行 npm run dev:online命令
      "runtimeArgs": [
        "run",
        "dev:online"
      ]
    }
  ]
}

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "CLI debug",
      // 这里是项目地址
      "cwd": "/Users/55utah/workspace/reportx12/reportx",
      // 这里面是脚本路径
      "program": "xxx/node_modules/.bin/taro",
      // 给脚本传的参数，实际执行taro build --type
      "args": [
          "build",
          "--type"
      ],
    }
  ]
}

const iframe = document.createElement("iframe");
iframe.srcdoc = `<!DOCTYPE html><p>Hello World!</p>`;
document.body.appendChild(iframe);

const c = (n) => console.warn(n)

useEffect(() => {
   c(1) 
   return () => { c(2) } 
}, [])

useEffect(() => {
    c(3)
    return () => { c(4) }
}, [props.show])

// 初始化时
1
3
// props.show变化
4
3
// 组件卸载
2
4

// 调试node, 执行npm命名
// 在项目.vscode文件夹下添加 launch.json 设置如下配置
{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "CLI debug",
      // 这里是项目地址
      "cwd": "/Users/55utah/workspace/reportx/reportx_taro3/reportx",
      // 指定执行npm命令
      "runtimeExecutable": "npm",
      // 这里指执行 npm run dev:online命令
      "runtimeArgs": [
        "run",
        "dev:online"
      ]
    }
  ]
}

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "CLI debug",
      // 这里是项目地址
      "cwd": "/Users/55utah/workspace/reportx/reportx_taro3/reportx",
      // 这里面是脚本路径
      "program": "xxx/node_modules/.bin/taro",
      // 给脚本传的参数，实际执行taro build --type
      "args": [
          "build",
          "--type"
      ],
    }
  ]
}

// 利用浮动把按钮加在又下角 && 利用遮挡方式支持未超出时，不显示按钮；
// 省略号是在按钮前伪元素实现的。
<html>
  <header>
    <style>
      .wrapper {
        display: flex;
        margin: 50px auto;
        width: 80%;
        overflow: hidden;
      }
      .text {
        overflow: hidden;
        text-overflow: ellipsis;
        text-align: justify;
        position: relative;
        line-height: 1.5;
        font-size: 20px;
        max-height: 4.5em;
      }
      .text::before {
        content: '';
        width: 0;
        height: 100%;
        margin-bottom: -24px;
        float: right;
      }
      .text::after {
        content: '';
        width: 100%;
        height: 100%;
        position: absolute;
        background: #fff;
      }
      .btn {
        float: right;
        clear: both;
        width: 40px;
        height: 20px;
        position: relative;
        margin-left: 20px;

        font-size: 14px;
        background-color: blue;
        color: white;
        text-align: center;
        border-radius: 4px;
      }
      .btn::before{
        content: '...';
        position: absolute;
        left: -5px;
        color: #333;
        transform: translateX(-100%)
      }
    </style>
  </header>
  <body>
    <div class='wrapper'>
    <div class="text">
    <label class="btn">展开</label>
    浮动元素是如何定位的
正如我们前面提到的那样，当一个元素浮动之后，它会被移出正常的文档流，然后向左或者向右平移，一直平移直到碰到了所处的容器的边框，或者碰到另外一个浮动的元素。
在下面的图片中，有三个红色的正方形。其中有两个向左浮动，一个向右浮动。要注意到第二个向左浮动的正方形被放在第一个向左浮动的正方形的右边。如果还有更多的正方形。
  </div>
  </div>
  </body>
</html>

正面：
P1 P1 P1
X P1 X
X P1 X
正面下中的P1下方是B
左侧：
B B B
B B X
X X X
需要将正面下中的P1绕中间旋转到左侧右中位置
旋转方法：
下右、左下、下左、左上、下左、正面逆时针转、下右、正面顺时针转
如果是将正面下中移动到右中，第一步是下左，第二步是右下，然后类似

基础过程：右下、下左、右上、下右、右上、正面逆时针、右下、正面顺时针；
其他细节不予记录；

底层"小鱼"置于左上角，如果双头鱼，则"小鱼左下角"；
正面，使用233法则：
右下、下右、左下（形成233，然后开始恢复）、下左、右上、下右、左上；
可反复使用，调整小鱼方向，直到形成小鱼或底层全恢复

首先一定要找到侧面两个角相同的那一面，将这一面放在右侧；
然后执行：
右下、下右、左下（形成233，然后开始恢复）、下左、右上、下右、下右、左上、下右、左下、下左、下左、左上
没有成功就多做几次；

首先如果侧面有一面已复原，就置于背面；
执行：
正面中间列向下、正面中间列向下（白色列到底层）、下右、正面中间列向上、下右、下右、正面中间列向下、下右、正面中间列向上、正面中间列向上；
未恢复重复执行；

1. 解法
因为 2的10次方是1024 所以我们可以用10只小鼠按2进制编码 来达到1000种结果的目的 也就是10位二进制数字；
比如：小鼠从0到9编号 从右到左排队  比如十进制11二进制表示是1011 那就是 0 1 3 三只小鼠去喝11号杯子的水，
依次类推 就有1000种组合  如果50分钟后 0 1 3三只小鼠死掉 那就说明11号杯子有毒；

同样的如果有x只小鼠，那么就最多可以辨别 2^x -1 瓶水中的一瓶毒药（比如3只小鼠可以鉴别7瓶）。
2. 解法
转换为线性代数方式解决
https://www.bilibili.com/video/BV1Fy4y1T7mL

[email protected] 之后的版本增加了 npm run <initializer> 这样的操作，即执行
npm run thinkjs
时，npm会补全为create-thinkjs并执行
npx create-thinkjs
完整的规则：
* npm init foo -> npx create-foo
* npm init @usr/foo -> npx @usr/create-foo
* npm init @usr -> npx @usr/create

npm init vite-app
# same as 
npx create-vite-app

npm init vite-app <project-name>
相当于 npx create-vite-app <project-name>
执行create-vite-app命令传参数project-name

场景：
使用<a target="_blank"> 或者 window.open()打开新页面，不做特殊处理的话，新页面可以使用
**window.opener**
访问当前页面的window对象！
其中一个后果是在新页面使用window.opener.location = 'xx.com'后直接修改了原页面地址。
某些论坛等外链可能会修改原本页面地址，引导用户进入恶意网站，或者修改window属性值，
达到看恶意攻击的目的。

方案就是禁止新页面获取到原本页面的window对象
页面增加如下代码：
const otherWindow = window.open()
otherWindow.opener = null
这样新页面获取到的window.opener对象就是null

let a = {j: 0}, b = a
Object.is(a, b)
//true

.content {
  width: 980px;
  margin-left: auto;
  margin-right auto;
}
不应该偷懒，写成
.content {
  width: 980px;
  margin: 0 auto;
}
css代码要符合最小影响原则，水平居中不应该设置top, bottom的margin.
这个要记住。

function pulse() {
  t && data.push(Date.now() - t)
  t = Date.now()
  setTimeout(pulse, 50)
}
pulse()

$ node-modules/.bin/mocha --version

commonJS规范：
在node端使用
require('xx.js')
module.exports
amd规范
浏览器使用
require(['dep1'], function(){})
接受依赖列表， 和一个回调函数，异步读取依赖后执行回调。
angular使用requirejs这种AMD规范实现来做浏览器端的模块开发方式；

if (a) {
    this.data = xx;
    this.dispatchEvent(new Event("load"));
} else {
    fetch(url).then(result => result.arrayBuffer()).then(data => {
      this.cache[url] = data;
      this.data = data;
      this.dispatchEvent(new Event("load"));
    )};
}

if (a) {
	queueMicrotask(() => {
		this.data = xx;
    	this.dispatchEvent(new Event("load"));
	})
} else {
    fetch(url).then(result => result.arrayBuffer()).then(data => {
      this.cache[url] = data;
      this.data = data;
      this.dispatchEvent(new Event("load"));
    )};
}

1. 属性名如果是数字，按从小到大排序输出；如果是字符串或者symbol类型，按属性创建时间先后排序；
2. 如果是数字、字符串、symbol混合，则先输出数字，再字符串，最后symbol

1. Object.entries
2. Object.values
3. for...in循环
4. Object.getOwnPropertyNames
5. Reflect.ownKeys

Object.keys({
    4: '12',
    'b': 'b-v',
    2: '11',
    'a': 'a-v',
    0: '222',
    'c': 'c-v',
})
// ["0", "2", "4", "b", "a", "c"]

// 可以看到数字属性名被转字符串并按规则组织顺序。

再测试Object.values
Object.values({
    4: '12',
    'b': 'b-v',
    2: '11',
    'a': 'a-v',
    0: '222',
    'c': 'c-v',
})
//  ["222", "11", "12", "b-v", "a-v", "c-v"]

ToPrimitive介绍
如果是原始值返回本身，不然调用valueOf，返回是原始值就返回本身；否则调用toString;

+null
0
+undefined
Nan
+false
0
+''
0
+'123'
123
+'xc'
NaN
+{}
NaN
+[]
NaN

1. true + false
// 1
二元相加，基础类型不是对象，没有字符串，就转为数字
=> 1 + 0 => 1
2. [,,,].length
// 3
比如[,].length == 1
数组最后一个空逗号尾后逗号，会被忽略。如
var arr = [
  1,
  2,
  3,
];
arr; // [1, 2, 3]
3. [1, 2, 3] + [4, 5, 6]
// "1,2,34,5,6"
4. 10,2,3
// 3
逗号运算符，只会返回最后一个值。
1, 2, 3, 4; // -> 4
42, "pineapple", true; // -> true
5. +!![]
// 1
转布尔值，[]是对象一律转为true => +true => 1
6. 1/0; // -> Infinity
7. 

Array.from("abc")
// ['a', 'b', 'c']

Array.from({ length: 10 }, (_, i) => i + 1)
// [1, 2, 3, .....]

// 可以从类数组生成数组，所以，可以从{ length: 10 } 这样的对象生成；
// 第二个参数是一个函数，对生成数组的每个元素转换

动态规划有两种基本思路：
1. 自顶向下
使用dp函数，从大的结果一路计算到基础状态。
2. 自下而上
使用dp table，也就是dp数组，从小的基础状态向上不断计算，直到计算出大的结果。

# 初始化 base case
dp[0][0][...] = base
# 进行状态转移
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

int fib(int N) {
    if (N == 1 || N == 2) return 1;
    return fib(N - 1) + fib(N - 2);
}

int fib(int N) {
    // 备忘录全初始化为 0
    int[] memo = new int[N + 1];
    // 进行带备忘录的递归
    return helper(memo, N);
}

int helper(int[] memo, int n) {
    // base case
    if (n == 0 || n == 1) return n;
    // 已经计算过，不用再计算了
    if (memo[n] != 0) return memo[n];
    memo[n] = helper(memo, n - 1) + helper(memo, n - 2);
    return memo[n];
}

int fib(int N) {
    if (N == 0) return 0;
    int[] dp = new int[N + 1];
    // base case
    dp[0] = 0; dp[1] = 1;
    // 状态转移
    for (int i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[N];
}

int fib(int n) {
    if (n < 1) return 0;
    if (n == 2 || n == 1) 
        return 1;
    int prev = 1, curr = 1;
    for (int i = 3; i <= n; i++) {
        int sum = prev + curr;
        prev = curr;
        curr = sum;
    }
    return curr;
}

// 伪码框架
int coinChange(int[] coins, int amount) {
    // 题目要求的最终结果是 dp(amount)
    return dp(coins, amount)
}

// 定义：要凑出金额 n，至少要 dp(coins, n) 个硬币
int dp(int[] coins, int n) {
    // 做选择，选择需要硬币最少的那个结果
    for (int coin : coins) {
        res = min(res, 1 + dp(n - coin))
    }
    return res
}

int coinChange(int[] coins, int amount) {
    // 题目要求的最终结果是 dp(amount)
    return dp(coins, amount)
}

int dp(int[] coins, int amount) {
    // base case
    if (amount == 0) return 0;
    if (amount < 0) return -1;

    int res = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 计算子问题的结果
        int subProblem = dp(coins, amount - coin);
        // 子问题无解则跳过
        if (subProblem == -1) continue;
        // 在子问题中选择最优解，然后加一
        res = Math.min(res, subProblem + 1);
    }

    return res == Integer.MAX_VALUE ? -1 : res;
}

int[] memo;

int coinChange(int[] coins, int amount) {
    memo = new int[amount + 1];
    // dp 数组全都初始化为特殊值
    Arrays.fill(memo, -666);

    return dp(coins, amount);
}

int dp(int[] coins, int amount) {
    if (amount == 0) return 0;
    if (amount < 0) return -1;
    // 查备忘录，防止重复计算
    if (memo[amount] != -666)
        return memo[amount];

    int res = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 计算子问题的结果
        int subProblem = dp(coins, amount - coin);
        // 子问题无解则跳过
        if (subProblem == -1) continue;
        // 在子问题中选择最优解，然后加一
        res = Math.min(res, subProblem + 1);
    }
    // 把计算结果存入备忘录
    memo[amount] = (res == Integer.MAX_VALUE) ? -1 : res;
    return memo[amount];
}

int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    // 数组大小为 amount + 1，初始值也为 amount + 1
    Arrays.fill(dp, amount + 1);

    // base case
    dp[0] = 0;
    // 外层 for 循环在遍历所有状态的所有取值
    for (int i = 0; i < dp.length; i++) {
        // 内层 for 循环在求所有选择的最小值
        for (int coin : coins) {
            // 子问题无解，跳过
            if (i - coin < 0) {
                continue;
            }
            dp[i] = Math.min(dp[i], 1 + dp[i - coin]);
        }
    }
    return (dp[amount] == amount + 1) ? -1 : dp[amount];
}

<div id="A><div id="B">B</div></div>

function handle(e) {
  console.warn(e.target.id, e.currentTarget.id)
}
document.querySelector('#A').onclick = handle

// 点击B
// 打印 B A

module.exports = {
  // 这个parser可以帮助检测ts相关问题
  parser: '@typescript-eslint/parser',
  // 可以继承一个已有配置
  extends: ['@bdxxxx/eslint-config-xxxxx'],
  // 三个eslint插件分别处理文件夹/文件名/导入；需要dev安装eslint-plugin-filenames；eslint-plugin-folders；eslint-plugin-import；
  plugins: ['folders', 'filenames', 'import'],
  ignorePatterns: ['src/services/api/typings/**/*.ts', 'src/services/tea/types/**/*.ts'],
  rules: {
    '@typescript-eslint/no-non-null-asserted-optional-chain': 'off',
    '@typescript-eslint/explicit-function-return-type': 'off',
    '@typescript-eslint/explicit-member-accessibility': 'off',
    '@typescript-eslint/no-empty-function': 'off',
    'react/destructuring-assignment': 'warn',
    'react/react-in-jsx-scope': 'off',
    'no-shadow': 'warn',
    'no-sequences': ['error', { allowInParentheses: false }],
    // 这里控制了文件名/文件夹名必须的格式；
    'filenames/match-regex': [2, '^[a-z0-9][a-z0-9-.]*[a-z0-9]$', '/src'],
    'folders/match-regex': [2, '^[a-z0-9][a-z0-9-]*[a-z0-9]$', '/src'],
    'import/no-nodejs-modules': 'off',
    // disallow non-import statements appearing before import statements
    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/first.md
    // 这个控制import内容的顺序，必须绝对路径在相对路径前面
    'import/first': ['error', 'absolute-first'],
    'import/imports-first': 'off',
    'import/order': ['off', {
      groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
      'newlines-between': 'never'
    }],
    // 控制import内容和正式内容之间必须有一行间隔；
    'import/newline-after-import': 'error',
  },
  parserOptions: {
    project: 'tsconfig.json',
   // 这个配置可以让eslint在monorepo模式下生效；
    tsconfigRootDir: __dirname,
    sourceType: 'module',
  },
}