·
├── directives
├──├── index.ts
├──├── modules
├──├──├── some directive
├──├──├──├── index.ts type.ts ...

import type { Directive } from 'vue'
import type { App } from 'vue'
export type { DebounceBindingOptions } from './modules/debounce/type'
export type { ThrottleBindingOptions } from './modules/throttle/type'
export type CustomDirectiveFC<T, K> = () => Directive<T, K>
export interface DirectiveModules extends Object {
  default: CustomDirectiveFC<unknown, unknown>
}
export type AppType = App<Element>

import type { DirectiveModules, CustomDirectiveFC } from '@/directives/type'
export const combineDirective = <
  T extends Record<string, DirectiveModules>,
  K extends keyof T,
>(
  directiveModules: T,
) => {
  const directives = Object.keys(directiveModules).reduce((pre, curr) => {
    const fc = directiveModules[curr]?.default
    if (typeof fc === 'function') {
      pre[curr] = fc
      return pre
    } else {
      throw new Error('directiveModules[curr] is not function')
    }
  }, {} as Record<K, CustomDirectiveFC<unknown, unknown>>)
  return directives
}

import { combineDirective } from './helper/combine'
import { forIn } from 'lodash-es'
import type { App } from 'vue'
import type { DirectiveModules } from '@/directives/type'
/**
 *
 * 初始化全局自定義指令
 *
 * 該方法會將 modules 下每個文件夾視為一個指令
 * 并且會將文件夾名稱識別為指令名稱
 * 每個文件下的 index.ts 文件視為每個指令的入口(也就是指令的處理邏輯, 需要暴露出一個 Directive 類型的對象)
 */
export const setupDirectives = (app: App<Element>) => {
  // 獲取 modules 包下所有的 index.ts 文件
  const directiveRawModules: Record<string, DirectiveModules> =
    import.meta.glob('@/directives/modules/**/index.ts', {
      eager: true,
    })
  // 將所有的包提取出來(./modules/[file-name]/index.ts)
  const directivesModules = combineDirective(directiveRawModules)
  // 提取文件名(./modules/copy/index.ts => copy)
  const regexExtractDirectiveName = /(?<=modules\/).*(?=\/index\.ts)/
  // 匹配合法指令名稱
  const regexDirectiveName = /^([^-]+-)*[^-]+$/
  forIn(directivesModules, (value, key) => {
    const dname = key.match(regexExtractDirectiveName)?.[0]
    if (typeof dname === 'string' && regexDirectiveName.test(dname)) {
      app.directive(dname, value?.())
    } else {
      console.error(`[setupDirectives] ${dname} is not a valid directive name`)
    }
  })
}

import type { ThrottleSettings } from 'lodash-es'
import type { AnyFC } from '@/types/modules/utils'
export interface ThrottleBindingOptions {
  func: AnyFC
  trigger?: string
  wait?: number
  options?: ThrottleSettings
}

import { throttle } from 'lodash-es'
import { on, off } from '@use-utils/element'
import type { ThrottleBindingOptions } from './type'
import type { AnyFC } from '@/types/modules/utils'
import type { DebouncedFunc } from 'lodash-es'
import type { CustomDirectiveFC } from '@/directives/type'
const throttleDirective: CustomDirectiveFC<
  HTMLElement,
  ThrottleBindingOptions
> = () => {
  let throttleFunction: DebouncedFunc<AnyFC> | null
  return {
    beforeMount: (el, { value }) => {
      const { func, trigger = 'click', wait = 500, options } = value
      if (typeof func !== 'function') {
        throw new Error('throttle directive value must be a function')
      }
      throttleFunction = throttle(func, wait, Object.assign({}, options))
      on(el, trigger, throttleFunction)
    },
    beforeUnmount: (el, { value }) => {
      const { trigger = 'click' } = value
      if (throttleFunction) {
        throttleFunction.cancel()
        off(el, trigger, throttleFunction)
      }
      throttleFunction = null
    },
  }
}
export default throttleDirective

<template>
  <p>我執(zhí)行了{(lán){ count }}次</p>
  <p>該方法 1s 內(nèi)僅會執(zhí)行一次</p>
  <button
    v-throttle="{
      func: handleClick,
      trigger: 'click',
      wait: 1000,
      options: {},
    }"
  >
    節(jié)流按鈕
  </button>
</template>
<script setup lang="ts">
const count = ref(0)
const handleClick = () => {
  count.value++
}
</script>

import type { DebounceSettings } from 'lodash-es'
import type { AnyFC } from '@/types/modules/utils'
export interface DebounceBindingOptions {
  func: AnyFC
  trigger?: string
  wait?: number
  options?: DebounceSettings
}

import { debounce } from 'lodash-es'
import { on, off } from '@use-utils/element'
import type { DebounceBindingOptions } from './type'
import type { AnyFC } from '@/types/modules/utils'
import type { DebouncedFunc } from 'lodash-es'
import type { CustomDirectiveFC } from '@/directives/type'
const debounceDirective: CustomDirectiveFC<
  HTMLElement,
  DebounceBindingOptions
> = () => {
  let debounceFunction: DebouncedFunc<AnyFC> | null
  return {
    beforeMount: (el, { value }) => {
      const { func, trigger = 'click', wait = 500, options } = value
      if (typeof func !== 'function') {
        throw new Error('debounce directive value must be a function')
      }
      debounceFunction = debounce(func, wait, Object.assign({}, options))
      on(el, trigger, debounceFunction)
    },
    beforeUnmount: (el, { value }) => {
      const { trigger = 'click' } = value
      if (debounceFunction) {
        debounceFunction.cancel()
        off(el, trigger, debounceFunction)
      }
      debounceFunction = null
    },
  }
}
export default debounceDirective

<template>
  <p>我執(zhí)行了{(lán){ count }}次</p>
  <p>該方法將延遲 1s 執(zhí)行</p>
  <button
    v-throttle="{
      func: handleClick,
      trigger: 'click',
      wait: 1000,
      options: {},
    }"
  >
    防抖按鈕
  </button>
</template>
<script setup lang="ts">
const count = ref(0)
const handleClick = () => {
  count.value++
}
</script>

·
├── directives
├──├── index.ts type.ts
├──├── modules
├──├──├── throttle
├──├──├──├── index.ts type.ts
├──├──├── debounce
├──├──├──├── index.ts type.ts