/*
 * 創建事件發射器，用于注冊、移除和觸發事件
 * @param {Map} all - 存儲所有事件類型及其對應的處理函數的 Map 對象
 * @returns {Object} - 包含 all、on、off 和 emit 方法的對象
 */
function mitt(all) {
  all = all || new Map();

  return {
    // 事件名稱與已注冊的處理函數之間的映射表
    all,

    /**
     * 注冊事件處理函數
     * @param {string} type - 要監聽的事件類型（用 '*'表示所有事件）
     * @param {function} handler - 響應指定事件時要調用的函數
     */
    on(type, handler) {
      // 獲取事件類型對應的處理函數列表
      const handlers = all.get(type);
      // 已有處理函數，將新處理函數添加到處理函數列表；沒有，則用新處理函數初始化處理函數列表
      if (handlers) {
        handlers.push(handler);
      } else {
        all.set(type, [handler]);
      }
    },

    /**
     * 注銷事件處理函數
     * 如果省略 handler，則會注銷所有指定類型的處理程序
     * @param {string} type - 要注銷注冊 handler的事件類型（用 '＊'刪除通配符處理程序）
     * @param {function} handler - 要注銷的處理函數
     */
    off(type, handler) {
      const handlers = all.get(type);
      if (handlers) {
        // 如果指定了要注銷的事件處理函數，從處理函數列表中移除它；
        // 未指定，則將該事件類型的處理函數列表清空
        if (handler) {
          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
        } else {
          all.set(type, []);
        }
      }
    },

    /**
     * 觸發事件，調用指定類型的所有處理程序。
     * 如果存在，將在匹配類型的處理程序之后調用 '*' 處理程序。
     * 
     * 注意：不支持手動觸發 '*' 處理程序
     * @param {string} type - 要觸發的事件類型
     * @param {any} evt - 傳遞給每個事件處理函數的參數（推薦對象）
     */
    emit(type, evt) {
      let handlers = all.get(type);
      if (handlers) {
        // 如果有處理函數，依次調用處理函數并傳入參數
        // 注：使用 slice 函數用于創建數組的副本，避免影響原始列表
        handlers
          .slice()
          .map((handler) => {
            handler(evt);
          });
      }

      // 獲取通配符事件類型對應的處理函數列表，有則依次調用并傳參
      handlers = all.get('*');
      if (handlers) {
        handlers
          .slice()
          .map((handler) => {
            handler(type, evt);
          });
      }
    },
  };
}

const emitter = mitt()

// 監聽一個事件
emitter.on('foo', e => console.log('foo', e) )

// 監聽所有事件
emitter.on('*', (type, e) => console.log(type, e) )

// 觸發一個事件
emitter.emit('foo', { a: 'b' })

// 清除所有事件
emitter.all.clear()

// 使用處理函數引用
function onFoo() {}
emitter.on('foo', onFoo)   // 監聽
emitter.off('foo', onFoo)  // 移除監聽

handlers.splice(handlers.indexOf(handler) >>> 0, 1);

handlers.slice().map((handler) => {
  handler(evt);
});

export type EventType = string | symbol;

// 事件處理器，可選的事件參數，不返回值
export type Handler<T = unknown> = (event: T) => void;
// 定義一個通用的事件處理函數類型，可以處理多種不同類型的事件
export type WildcardHandler<T = Record<string, unknown>> = (
 type: keyof T, // 必須是 T 類型中的某個屬性名稱
 event: T[keyof T] // 必須是 T 類型中所有屬性值的聯合類型
) => void;

// 一個包含當前已注冊的某種類型事件處理程序的數組
export type EventHandlerList<T = unknown> = Array<Handler<T>>;
export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;

// 一個 Map 類型，用于存儲事件類型及其處理函數列表
// 在 TypeScript 中，Map 是一個泛型類型，可以指定鍵和值的類型。例如，Map<string, number> 表示一個鍵為字符串類型，值為數字類型的 Map 對象。
export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
  keyof Events | '*',
  // EventHandlerList<Events[keyof Events]> 表示一個處理 Events[keyof Events] 類型事件的處理函數列表，也就是說，事件類型為 Events 中所有屬性值的聯合類型。
  // WildCardEventHandlerList<Events> 表示一個處理所有事件類型的處理函數列表
  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
>;

export interface Emitter<Events extends Record<EventType, unknown>> {
  all: EventHandlerMap<Events>;

  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
  // 通配符事件類型 '*' 的重載
  on(type: '*', handler: WildcardHandler<Events>): void;

  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
  off(type: '*', handler: WildcardHandler<Events>): void;

  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
}

function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events> {
  // 兩種事件處理器的聯合類型
  type GenericEventHandler =| Handler<Events[keyof Events]> | WildcardHandler<Events>;

  return {
    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {/*...*/},
    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {/*...*/},
    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {/*...*/}
  };
}

{
  "scripts": {
    // 運行 "typecheck", "lint", "mocha" 和 "test-types" 命令
    "test": "npm-run-all --silent typecheck lint mocha test-types",
    // 運行 "test" 目錄下的 mocha 測試
    "mocha": "mocha test",
    // 運行 TypeScript 編譯器，檢查 test/test-types-compilation.ts 文件的類型，但不生成任何輸出
    "test-types": "tsc test/test-types-compilation.ts --noEmit --strict",
    // 運行 ESLint 檢查 src 和 test 目錄下的 .ts 和 .js 文件
    "lint": "eslint src test --ext ts --ext js",
    // 運行 TypeScript 編譯器，檢查 TypeScript 代碼的類型，但不生成任何輸出
    "typecheck": "tsc --noEmit",
    // 使用 microbundle 將模塊打包成 ES、CommonJS 和 UMD 格式
    "bundle": "microbundle -f es,cjs,umd",
    // 運行 "clean", "bundle" 和 "docs" 命令
    "build": "npm-run-all --silent clean -p bundle -s docs",
    // 刪除 dist 目錄
    "clean": "rimraf dist",
    // 使用 documentation 工具生成 API 文檔
    "docs": "documentation readme src/index.ts --section API -q --parse-extension ts",
    // 運行 "build", "test" 命令，提交代碼，打標簽，推送到 Git 倉庫，發布到 npm
    "release": "npm run -s build -s && npm t && git commit -am $npm_package_version && git tag $npm_package_version && git push && git push --tags && npm publish"
  }
}

{
  "mocha": {
    // 指定測試文件的擴展名為 ".ts"
    "extension": [
      "ts"
    ],
    // 指定需要在測試運行前加載的模塊。這里指定了 "ts-node/register" 和 "esm" 模塊，它們分別用于支持 TypeScript 和 ES modules
    "require": [
      "ts-node/register",
      "esm"
    ],
    // 指定測試文件的位置，這里表示所有以 "_test.ts" 結尾的文件都會被作為測試文件運行
    "spec": [
      "test/*_test.ts"
    ]
  },
}

{
  "eslintConfig": {
    // 指定一個或多個已有的ESLint配置文件，以便繼承其中的規則和選項
    "extends": [
      "developit",
      // plugin: 表示對 @typescript-eslint 插件下的某一類配置對象的引用
      "plugin:@typescript-eslint/eslint-recommended",
      "plugin:@typescript-eslint/recommended"
    ],
    // 專門用于解析 TypeScript 代碼的解析器
    "parser": "@typescript-eslint/parser",
    "parserOptions": {
      // 要解析的代碼是 ES6 模塊
      "sourceType": "module"
    },
    "env": {
      "browser": true,
      "mocha": true,
      "jest": false,
      "es6": true
    },
    // 指定了 expect 變量為全局變量，用于在測試中使用斷言庫
    "globals": {
      "expect": true
    },
    "rules": {
      // ...
    }
  },
  // 指定ESLint應該忽略的文件或目
  "eslintIgnore": [
    "dist",
    "index.d.ts"
  ]
}

{
  // 定義了 ES6 模塊規范的入口文件。當使用現代打包工具（如 webpack、Rollup 等）構建項目時，會自動使用這個屬性指定的文件作為入口，以支持 ES6 模塊的導入和導出。
  "module": "dist/mitt.mjs",
  // 定義了 CommonJS 規范的入口文件。當使用 Node.js 運行時或者其他支持 CommonJS 規范的環境時，會自動使用這個屬性指定的文件作為入口。
  "main": "dist/mitt.js",
  // 定義了 ES6 模塊規范的入口文件。這個屬性主要是為了向老版本的打包工具提供兼容性支持，因為老版本的打包工具不支持 module 屬性。
  "jsnext:main": "dist/mitt.mjs",
  // 定義了 UMD 規范的入口文件。當使用不支持 ES6 模塊或 CommonJS 規范的環境時，會自動使用這個屬性指定的文件作為入口。
  "umd:main": "dist/mitt.umd.js",
  // 定義了源代碼文件的入口。這個屬性通常用于調試和開發環境，因為它可以讓開發者在調試時直接跳轉到源代碼文件，而不是跳轉到編譯后的文件。
  "source": "src/index.ts",
  // 定義了 TypeScript 類型定義文件的路徑。這個屬性通常用于 TypeScript 項目，它告訴 TypeScript 編譯器在編譯時需要將這個文件作為類型定義文件使用。
  "typings": "index.d.ts",
  // 定義了模塊的導出方式。是可以指定多個導出方式的對象，包括 import、require、types 和 default。以便在不同的環境下使用不同的導出方式，以適應不同的場景。
  "exports": {
    "types": "./index.d.ts",
    "import": "./dist/mitt.mjs",
    "require": "./dist/mitt.js",
    "default": "./dist/mitt.mjs"
  },
  // 用于指定哪些文件是該模塊的一部分，這些文件將會被打包到該模塊中，以便在其他項目中使用。
  // 默認情況下，所有文件都會被打包到該模塊中，包括 node_modules 目錄和測試文件等。
  "files": [
    "dist",
    "index.d.ts"
  ],
}

# 定義名為 CI 的工作流
name: CI

on:
  # 當有新的 pull request 提交時，且提交的分支名符合 ** 通配符模式時；
  pull_request:
    branches:
      - "**"
  # 當在 main 分支上進行 push 操作時。
  push:
    branches:
      - main

jobs:
  # 定義名為 build 作業（job）
  build:
    # 指定運行環境為 ubuntu-latest
    runs-on: ubuntu-latest
    # 定義步驟
    steps:
      # 使用 actions/checkout@v2 動作來檢出代碼庫
      - uses: actions/checkout@v2
      # 使用 actions/setup-node@v2 動作來安裝 Node.js 運行環境，指定版本為 14
      - uses: actions/setup-node@v2
        with:
          node-version: 14
      # 定義一個名為 npm install, build, and test 的步驟
      - name: npm install, build, and test
        # 包含以下命令
        run: |
          npm install
          npm run build --if-present # 如果有定義 build 命令，則運行該命令，用于打包構建項目；
          npm test
        # 定義一個名為 CI 的環境變量，將其值設為 true
        env:
          CI: true