Vue3 企業級優雅實戰 - 元件庫框架 - 9 實現元件庫 cli - 上

程式設計師優雅哥(公\/同)發表於2023-02-08

上文搭建了元件庫 cli 的基礎架子,實現了建立元件時的使用者互動,但遺留了 cli/src/command/create-component.ts 中的 createNewComponent 函式,該函式要實現的功能就是上文開篇提到的 —— 建立一個元件的完整步驟。本文我們們就依次實現那些步驟。(友情提示:本文內容較多,如果你能耐心看完、寫完,一定會有提升)

1 建立工具類

在實現 cli 的過程中會涉及到元件名稱命名方式的轉換、執行cmd命令等操作,所以在開始實現建立元件前,先準備一些工具類。

cli/src/util/ 目錄上一篇文章中已經建立了一個 log-utils.ts 檔案,現繼續建立下列四個檔案:cmd-utils.tsloading-utils.tsname-utils.tstemplate-utils.ts

1.1 name-utils.ts

該檔案提供一些名稱元件轉換的函式,如轉換為首字母大寫或小寫的駝峰命名、轉換為中劃線分隔的命名等:

/**
 * 將首字母轉為大寫
 */
export const convertFirstUpper = (str: string): string => {
  return `${str.substring(0, 1).toUpperCase()}${str.substring(1)}`
}
/**
 * 將首字母轉為小寫
 */
export const convertFirstLower = (str: string): string => {
  return `${str.substring(0, 1).toLowerCase()}${str.substring(1)}`
}
/**
 * 轉為中劃線命名
 */
export const convertToLine = (str: string): string => {
  return convertFirstLower(str).replace(/([A-Z])/g, '-$1').toLowerCase()
}
/**
 * 轉為駝峰命名(首字母大寫)
 */
export const convertToUpCamelName = (str: string): string => {
  let ret = ''
  const list = str.split('-')
  list.forEach(item => {
    ret += convertFirstUpper(item)
  })
  return convertFirstUpper(ret)
}
/**
 * 轉為駝峰命名(首字母小寫)
 */
export const convertToLowCamelName = (componentName: string): string => {
  return convertFirstLower(convertToUpCamelName(componentName))
}

1.2 loading-utils.ts

在命令列中建立元件時需要有 loading 效果,該檔案使用 ora 庫,提供顯示 loading 和關閉 loading 的函式:

import ora from 'ora'

let spinner: ora.Ora | null = null

export const showLoading = (msg: string) => {
  spinner = ora(msg).start()
}

export const closeLoading = () => {
  if (spinner != null) {
    spinner.stop()
  }
}

1.3 cmd-utils.ts

該檔案封裝 shelljs 庫的 execCmd 函式,用於執行 cmd 命令:

import shelljs from 'shelljs'
import { closeLoading } from './loading-utils'

export const execCmd = (cmd: string) => new Promise((resolve, reject) => {
  shelljs.exec(cmd, (err, stdout, stderr) => {
    if (err) {
      closeLoading()
      reject(new Error(stderr))
    }
    return resolve('')
  })
})

1.4 template-utils.ts

由於自動建立元件需要生成一些檔案,template-utils.ts 為這些檔案提供函式獲取模板。由於內容較多,這些函式在使用到的時候再討論。

2 引數實體類

執行 gen 命令時,會提示開發人員輸入元件名、中文名、型別,此外還有一些元件名的轉換,故可以將新元件的這些資訊封裝為一個實體類,後面在各種操作中,傳遞該物件即可,從而避免傳遞一大堆引數。

2.1 component-info.ts

src 目錄下建立 domain 目錄,並在該目錄中建立 component-info.ts ,該類封裝了元件的這些基礎資訊:

import * as path from 'path'
import { convertToLine, convertToLowCamelName, convertToUpCamelName } from '../util/name-utils'
import { Config } from '../config'

export class ComponentInfo {
  /** 中劃線分隔的名稱,如:nav-bar */
  lineName: string
  /** 中劃線分隔的名稱(帶元件字首) 如:yyg-nav-bar */
  lineNameWithPrefix: string
  /** 首字母小寫的駝峰名 如:navBar */
  lowCamelName: string
  /** 首字母大寫的駝峰名 如:NavBar */
  upCamelName: string
  /** 元件中文名 如:左側導航 */
  zhName: string
  /** 元件型別 如:tsx */
  type: 'tsx' | 'vue'

  /** packages 目錄所在的路徑 */
  parentPath: string
  /** 元件所在的路徑 */
  fullPath: string

  /** 元件的字首 如:yyg */
  prefix: string
  /** 元件全名 如:@yyg-demo-ui/xxx */
  nameWithLib: string

  constructor (componentName: string, description: string, componentType: string) {
    this.prefix = Config.COMPONENT_PREFIX
    this.lineName = convertToLine(componentName)
    this.lineNameWithPrefix = `${this.prefix}-${this.lineName}`
    this.upCamelName = convertToUpCamelName(this.lineName)
    this.lowCamelName = convertToLowCamelName(this.upCamelName)
    this.zhName = description
    this.type = componentType === 'vue' ? 'vue' : 'tsx'
    this.parentPath = path.resolve(__dirname, '../../../packages')
    this.fullPath = path.resolve(this.parentPath, this.lineName)
    this.nameWithLib = `@${Config.COMPONENT_LIB_NAME}/${this.lineName}`
  }
}

2.2 config.ts

上面的實體中引用了 config.ts 檔案,該檔案用於設定元件的字首和元件庫的名稱。在 src 目錄下建立 config.ts

export const Config = {
  /** 元件名的字首 */
  COMPONENT_PREFIX: 'yyg',
  /** 元件庫名稱 */
  COMPONENT_LIB_NAME: 'yyg-demo-ui'
}

3 建立新元件模組

3.1 概述

上一篇開篇講了,cli 元件新元件要做四件事:

  1. 建立新元件模組;
  2. 建立樣式 scss 檔案並匯入;
  3. 在元件庫入口模組安裝新元件模組為依賴,並引入新元件;
  4. 建立元件庫檔案和 demo。

本文剩下的部分分享第一點,其餘三點下一篇文章分享。

src 下建立 service 目錄,上面四個內容拆分在不同的 service 檔案中,並統一由 cli/src/command/create-component.ts 呼叫,這樣層次結構清晰,也便於維護。

首先在 src/service 目錄下建立 init-component.ts 檔案,該檔案用於建立新元件模組,在該檔案中要完成如下幾件事:

  1. 建立新元件的目錄;
  2. 使用 pnpm init 初始化 package.json 檔案;
  3. 修改 package.json 的 name 屬性;
  4. 安裝通用工具包 @yyg-demo-ui/utils 到依賴中;
  5. 建立 src 目錄;
  6. 在 src 目錄中建立元件本體檔案 xxx.tsx 或 xxx.vue;
  7. 在 src 目錄中建立 types.ts 檔案;
  8. 建立元件入口檔案 index.ts。

3.2 init-component.ts

上面的 8 件事需要在 src/service/init-component.ts 中實現,在該檔案中匯出函式 initComponent 給外部呼叫:

/**
 * 建立元件目錄及檔案
 */
export const initComponent = (componentInfo: ComponentInfo) => new Promise((resolve, reject) => {
  if (fs.existsSync(componentInfo.fullPath)) {
    return reject(new Error('元件已存在'))
  }

  // 1. 建立元件根目錄
  fs.mkdirSync(componentInfo.fullPath)

  // 2. 初始化 package.json
  execCmd(`cd ${componentInfo.fullPath} && pnpm init`).then(r => {
    // 3. 修改 package.json
    updatePackageJson(componentInfo)

    // 4. 安裝 utils 依賴
    execCmd(`cd ${componentInfo.fullPath} && pnpm install @${Config.COMPONENT_LIB_NAME}/utils`)

    // 5. 建立元件 src 目錄
    fs.mkdirSync(path.resolve(componentInfo.fullPath, 'src'))

    // 6. 建立 src/xxx.vue 或s src/xxx.tsx
    createSrcIndex(componentInfo)

    // 7. 建立 src/types.ts 檔案
    createSrcTypes(componentInfo)

    // 8. 建立 index.ts
    createIndex(componentInfo)

    g('component init success')

    return resolve(componentInfo)
  }).catch(e => {
    return reject(e)
  })
})

上面的方法邏輯比較清晰,相信大家能夠看懂。其中 3、6、7、8抽取為函式。

**修改 package.json ** :讀取 package.json 檔案,由於預設生成的 name 屬性為 xxx-xx 的形式,故只需將該欄位串替換為 @yyg-demo-ui/xxx-xx 的形式即可,最後將替換後的結果重新寫入到 package.json。程式碼實現如下:

const updatePackageJson = (componentInfo: ComponentInfo) => {
  const { lineName, fullPath, nameWithLib } = componentInfo
  const packageJsonPath = `${fullPath}/package.json`
  if (fs.existsSync(packageJsonPath)) {
    let content = fs.readFileSync(packageJsonPath).toString()
    content = content.replace(lineName, nameWithLib)
    fs.writeFileSync(packageJsonPath, content)
  }
}

建立元件的本體 xxx.vue / xxx.tsx:根據元件型別(.tsx 或 .vue)讀取對應的模板,然後寫入到檔案中即可。程式碼實現:

const createSrcIndex = (componentInfo: ComponentInfo) => {
  let content = ''
  if (componentInfo.type === 'vue') {
    content = sfcTemplate(componentInfo.lineNameWithPrefix, componentInfo.lowCamelName)
  } else {
    content = tsxTemplate(componentInfo.lineNameWithPrefix, componentInfo.lowCamelName)
  }
  const fileFullName = `${componentInfo.fullPath}/src/${componentInfo.lineName}.${componentInfo.type}`
  fs.writeFileSync(fileFullName, content)
}

這裡引入了 src/util/template-utils.ts 中的兩個生成模板的函式:sfcTemplate 和 tsxTemplate,在後面會提供。

建立 src/types.ts 檔案:呼叫 template-utils.ts 中的函式 typesTemplate 得到模板,再寫入檔案。程式碼實現:

const createSrcTypes = (componentInfo: ComponentInfo) => {
  const content = typesTemplate(componentInfo.lowCamelName, componentInfo.upCamelName)
  const fileFullName = `${componentInfo.fullPath}/src/types.ts`
  fs.writeFileSync(fileFullName, content)
}

建立 index.ts:同上,呼叫 template-utils.ts 中的函式 indexTemplate 得到模板再寫入檔案。程式碼實現:

const createIndex = (componentInfo: ComponentInfo) => {
  fs.writeFileSync(`${componentInfo.fullPath}/index.ts`, indexTemplate(componentInfo))
}

init-component.ts 引入的內容如下:

import { ComponentInfo } from '../domain/component-info'
import fs from 'fs'
import * as path from 'path'
import { indexTemplate, sfcTemplate, tsxTemplate, typesTemplate } from '../util/template-utils'
import { g } from '../util/log-utils'
import { execCmd } from '../util/cmd-utils'
import { Config } from '../config'

3.3 template-utils.ts

init-component.ts 中引入了 template-utils.ts 的四個函式:indexTemplatesfcTemplatetsxTemplatetypesTemplate,實現如下:

import { ComponentInfo } from '../domain/component-info'

/**
 * .vue 檔案模板
 */
export const sfcTemplate = (lineNameWithPrefix: string, lowCamelName: string): string => {
  return `<template>
  <div>
    ${lineNameWithPrefix}
  </div>
</template>

<script lang="ts" setup name="${lineNameWithPrefix}">
import { defineProps } from 'vue'
import { ${lowCamelName}Props } from './types'

defineProps(${lowCamelName}Props)
</script>

<style scoped lang="scss">
.${lineNameWithPrefix} {
}
</style>
`
}

/**
 * .tsx 檔案模板
 */
export const tsxTemplate = (lineNameWithPrefix: string, lowCamelName: string): string => {
  return `import { defineComponent } from 'vue'
import { ${lowCamelName}Props } from './types'

const NAME = '${lineNameWithPrefix}'

export default defineComponent({
  name: NAME,
  props: ${lowCamelName}Props,
  setup (props, context) {
    console.log(props, context)
    return () => (
      <div class={NAME}>
        <div>
          ${lineNameWithPrefix}
        </div>
      </div>
    )
  }
})
`
}

/**
 * types.ts 檔案模板
 */
export const typesTemplate = (lowCamelName: string, upCamelName: string): string => {
  return `import { ExtractPropTypes } from 'vue'

export const ${lowCamelName}Props = {
} as const

export type ${upCamelName}Props = ExtractPropTypes<typeof ${lowCamelName}Props>
`
}

/**
 * 元件入口 index.ts 檔案模板
 */
export const indexTemplate = (componentInfo: ComponentInfo): string => {
  const { upCamelName, lineName, lineNameWithPrefix, type } = componentInfo

  return `import ${upCamelName} from './src/${type === 'tsx' ? lineName : lineName + '.' + type}'
import { App } from 'vue'
${type === 'vue' ? `\n${upCamelName}.name = '${lineNameWithPrefix}'\n` : ''}
${upCamelName}.install = (app: App): void => {
  // 註冊元件
  app.component(${upCamelName}.name, ${upCamelName})
}

export default ${upCamelName}
`
}

這樣便實現了新元件模組的建立,下一篇文章將分享其餘的三個步驟,並在 createNewComponent 函式中呼叫。

感謝閱讀本文,如果本文給了你一點點幫助或者啟發,還請三連支援一下,瞭解更多內容工薇號“程式設計師優雅哥”。

相關文章