348 lines
9.7 KiB
JavaScript
348 lines
9.7 KiB
JavaScript
import { readFileSync, readdirSync, writeFileSync, statSync, existsSync } from 'fs'
|
|
import { join, isAbsolute, dirname } from 'path'
|
|
import cheerio from 'cheerio'
|
|
import { render } from './page'
|
|
import { camelCase, union } from 'lodash'
|
|
import {
|
|
ScriptSnapshot,
|
|
ModuleKind,
|
|
getDefaultLibFilePath,
|
|
resolveModuleName,
|
|
sys,
|
|
createDocumentRegistry,
|
|
createLanguageService,
|
|
SyntaxKind,
|
|
forEachChild
|
|
} from 'typescript'
|
|
import ignore from './diff-ignore'
|
|
|
|
const docPath = join(__dirname, '../docs/components')
|
|
const typesDir = join(resolveLib('veui'), 'types')
|
|
const Ls = createLs()
|
|
|
|
function getIgnoreComponents () {
|
|
return Object.keys(ignore)
|
|
.filter(key => ignore[key] === '*')
|
|
}
|
|
|
|
function isIgnore (componentName, apiType, apiName) {
|
|
let container = ignore['*'][apiType]
|
|
if (container && container.includes(apiName)) {
|
|
return true
|
|
}
|
|
|
|
container = ignore[componentName]
|
|
return container
|
|
? container === '*' || (container[apiType] || []).includes(apiName)
|
|
: false
|
|
}
|
|
|
|
function getApiFromDocs () {
|
|
const ignoreComponents = getIgnoreComponents()
|
|
return readdirSync(docPath)
|
|
.reduce((acc, name) => {
|
|
const match = name.match(/(.+)\.md$/)
|
|
if (match && !ignoreComponents.includes(match[1])) {
|
|
const absPath = join(docPath, name)
|
|
acc[match[1]] = getComponentApiFromDoc(absPath)
|
|
}
|
|
return acc
|
|
}, {})
|
|
}
|
|
|
|
function getComponentApiFromDoc (docFile) {
|
|
const raw = readFileSync(docFile, 'utf8')
|
|
const { contents } = render(raw, docFile)
|
|
const $ = cheerio.load(contents)
|
|
const props = $('h3:contains(属性)+table > tbody > tr')
|
|
.map((i, el) => {
|
|
const tds = $(el).children()
|
|
return {
|
|
name: camelCase(tds.eq(0).text().trim()),
|
|
type: tds.eq(1).text().trim()
|
|
// defaultValue: tds.eq(2).text().trim()
|
|
}
|
|
})
|
|
.toArray()
|
|
.reduce((acc, { name, type }) => {
|
|
acc[name] = type
|
|
return acc
|
|
}, {})
|
|
|
|
const slots = $('h3:contains(插槽)+table > tbody > tr')
|
|
.map((i, el) => {
|
|
const tds = $(el).children()
|
|
return tds.eq(0).text().trim()
|
|
})
|
|
.toArray()
|
|
.reduce((acc, name) => {
|
|
acc[name] = null
|
|
return acc
|
|
}, {})
|
|
|
|
const emits = $('h3:contains(事件)+table > tbody > tr')
|
|
.map((i, el) => {
|
|
const tds = $(el).children()
|
|
return tds.eq(0).text().trim()
|
|
})
|
|
.toArray()
|
|
.reduce((acc, name) => {
|
|
// 过滤掉 <value> 这种事件
|
|
if (!name.match(/^<[-\w]+>$/)) {
|
|
acc[name] = null
|
|
}
|
|
return acc
|
|
}, {})
|
|
|
|
return {
|
|
props,
|
|
slots,
|
|
emits
|
|
}
|
|
}
|
|
|
|
function getApiFromVeuiTypes () {
|
|
const program = Ls.getProgram()
|
|
const inputs = readdirpSync(join(typesDir, 'components')).map(i => join(typesDir, 'components', i))
|
|
const re = /([^/]+)\.d\.ts$/
|
|
const result = {}
|
|
inputs.forEach(input => {
|
|
const name = re.exec(input)[1]
|
|
const save = api => {
|
|
result[name] = api
|
|
}
|
|
forEachChild(program.getSourceFile(input), (...args) => visit(save, ...args))
|
|
})
|
|
return result
|
|
}
|
|
|
|
function visit (saveApi, node) {
|
|
if (node.kind === SyntaxKind.ExportAssignment) {
|
|
const checker = Ls.getProgram().getTypeChecker()
|
|
const sym = checker.getSymbolAtLocation(node.expression) // node.expression: id to Autocomplete
|
|
const type = checker.getTypeAtLocation(sym.declarations[0].name)
|
|
const rt = type.getConstructSignatures()[0].getReturnType()
|
|
const all = rt.getProperties()
|
|
const props = all.find(sy => sy.escapedName === '$props')
|
|
let result = {}
|
|
|
|
result.props = checker
|
|
.getTypeOfSymbolAtLocation(props, node)
|
|
.getProperties()
|
|
.reduce((acc, sy) => {
|
|
acc[sy.escapedName] = checker.typeToString(checker.getTypeOfSymbolAtLocation(sy, node))
|
|
return acc
|
|
}, {})
|
|
|
|
const emits = all.find(sy => sy.escapedName === '$emit')
|
|
const emitsType = checker.getTypeOfSymbolAtLocation(emits, node)
|
|
const emitsCollection = emitsType.isIntersection()
|
|
? emitsType.types
|
|
: [emitsType]
|
|
|
|
result.emits = emitsCollection
|
|
.map(ty => {
|
|
return ty.getCallSignatures()[0]
|
|
.getParameters()
|
|
.reduce((acc, argSy) => {
|
|
const argType = checker.getTypeOfSymbolAtLocation(argSy, node)
|
|
|
|
const tstr = checker.typeToString(argType)
|
|
const matched = /^"([^"]+)"$/.exec(tstr)
|
|
acc[argSy.escapedName] = matched ? matched[1] : tstr
|
|
return acc
|
|
}, {})
|
|
})
|
|
.reduce((acc, { event, args }) => {
|
|
if (event !== 'string') {
|
|
acc[event] = args
|
|
}
|
|
return acc
|
|
}, {})
|
|
|
|
const slots = all.find(sy => sy.escapedName === '$scopedSlots')
|
|
const slotsType = checker
|
|
.getTypeOfSymbolAtLocation(slots, node)
|
|
.getProperties()
|
|
.reduce((acc, symbol) => {
|
|
acc[symbol.escapedName] = getScope(symbol, node, checker)
|
|
return acc
|
|
}, {})
|
|
|
|
result.slots = slotsType
|
|
|
|
saveApi(result)
|
|
}
|
|
}
|
|
|
|
function getScope (symbol, node, checker) {
|
|
const scopeSy = checker.getTypeOfSymbolAtLocation(symbol, node)
|
|
.getCallSignatures()[0].getParameters()[0]
|
|
if (!scopeSy) {
|
|
return {}
|
|
}
|
|
const type = checker.getTypeOfSymbolAtLocation(scopeSy, node)
|
|
.getProperties().reduce((acc, argSy) => {
|
|
const argType = checker.getTypeOfSymbolAtLocation(argSy, node)
|
|
|
|
acc[argSy.escapedName] = checker.typeToString(argType)
|
|
return acc
|
|
}, {})
|
|
return type
|
|
}
|
|
|
|
const typeDeps = [
|
|
'@vue/runtime-dom',
|
|
'vue-router',
|
|
'@vue/reactivity',
|
|
'@vue/shared',
|
|
'@vue/runtime-core'
|
|
]
|
|
|
|
function createLs () {
|
|
const options = {
|
|
module: ModuleKind.ESNext
|
|
}
|
|
const host = {
|
|
getScriptSnapshot: fileName => {
|
|
fileName = isAbsolute(fileName) ? fileName : join(typesDir, fileName)
|
|
if (!existsSync(fileName)) {
|
|
return undefined
|
|
}
|
|
const content = readFileSync(fileName).toString()
|
|
return ScriptSnapshot.fromString(content)
|
|
},
|
|
getScriptFileNames: () => readdirpSync(typesDir),
|
|
getScriptVersion: () => '1',
|
|
getCurrentDirectory: () => typesDir,
|
|
getCompilationSettings: () => options,
|
|
getDefaultLibFileName: options => getDefaultLibFilePath(options),
|
|
resolveModuleNames: (moduleNames, containingFile) => {
|
|
return moduleNames.map(moduleName => {
|
|
let { resolvedModule } = resolveModuleName(moduleName, containingFile, options, {
|
|
fileExists: sys.fileExists,
|
|
readFile: sys.readFile
|
|
})
|
|
|
|
if (resolvedModule) {
|
|
return resolvedModule
|
|
}
|
|
|
|
if (typeDeps.indexOf(moduleName) >= 0) {
|
|
const p = resolveLib(moduleName, containingFile, true)
|
|
if (p) {
|
|
return { resolvedFileName: p }
|
|
}
|
|
}
|
|
|
|
if (moduleName.startsWith('.')) {
|
|
const resolved = resolveRel(moduleName, containingFile)
|
|
if (resolved) {
|
|
return { resolvedFileName: resolved }
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
return createLanguageService(host, createDocumentRegistry())
|
|
}
|
|
|
|
function readdirpSync (toRead, prefix = '') {
|
|
return readdirSync(toRead)
|
|
.reduce((acc, file) => {
|
|
const realFile = join(toRead, file)
|
|
if (statSync(realFile).isDirectory()) {
|
|
acc = acc.concat(readdirpSync(realFile, `${file}/`))
|
|
} else {
|
|
acc.push(`${prefix}${file}`)
|
|
}
|
|
return acc
|
|
}, [])
|
|
}
|
|
|
|
function resolveLib (libName, containingFile, types) {
|
|
const options = containingFile
|
|
? { paths: [containingFile] }
|
|
: undefined
|
|
let libDir = dirname(require.resolve(libName, options))
|
|
let pkgPath = join(libDir, 'package.json')
|
|
while (!existsSync(pkgPath)) {
|
|
libDir = dirname(libDir)
|
|
pkgPath = join(libDir, 'package.json')
|
|
}
|
|
|
|
if (types) {
|
|
const pkg = require(pkgPath)
|
|
if (pkg.types || pkg.typings) {
|
|
return join(dirname(pkgPath), pkg.types || pkg.typings)
|
|
}
|
|
}
|
|
return libDir
|
|
}
|
|
|
|
function resolveRel (moduleName, containingFile) {
|
|
let target = join(dirname(containingFile), moduleName)
|
|
|
|
if (statSync(target).isDirectory() && existsSync(join(target, 'index.d.ts'))) {
|
|
return join(target, 'index.d.ts')
|
|
}
|
|
}
|
|
|
|
function diffApi (tsApi, docApi) {
|
|
const fallback = {
|
|
props: {},
|
|
slots: {},
|
|
emits: {}
|
|
}
|
|
return union(
|
|
Object.keys(tsApi),
|
|
Object.keys(docApi)
|
|
).map(compName => {
|
|
const { props, slots, emits } = tsApi[compName] || fallback
|
|
const { props: dProps, slots: dSlots, emits: dEmits } = docApi[compName] || fallback
|
|
return {
|
|
component: compName,
|
|
props: diffPart(props, dProps, true), // 这里是false可以检查props类型
|
|
slots: diffPart(slots, dSlots, true),
|
|
emits: diffPart(emits, dEmits, true)
|
|
}
|
|
})
|
|
}
|
|
|
|
function diffPart (ts = {}, doc = {}, loose = false) {
|
|
return union(
|
|
Object.keys(ts),
|
|
Object.keys(doc)
|
|
).map(key => {
|
|
return {
|
|
key,
|
|
ts: typeof ts[key] === 'undefined' ? 'undefined' : ts[key], // undefined 表示缺失
|
|
doc: typeof doc[key] === 'undefined' ? 'undefined' : doc[key],
|
|
match: loose
|
|
? ts.hasOwnProperty(key) && doc.hasOwnProperty(key)
|
|
: ts[key] === doc[key]
|
|
}
|
|
}).filter(({ match }) => !match)
|
|
}
|
|
|
|
function writeDiffFile () {
|
|
const tsApi = getApiFromVeuiTypes()
|
|
const docApi = getApiFromDocs()
|
|
const diff = diffApi(tsApi, docApi)
|
|
.map(item => {
|
|
item.props = item.props.filter(({ key }) => !isIgnore(item.component, 'props', key))
|
|
item.emits = item.emits.filter(({ key }) => !isIgnore(item.component, 'emits', key))
|
|
item.slots = item.slots.filter(({ key }) => !isIgnore(item.component, 'slots', key))
|
|
return item
|
|
})
|
|
.filter(({ props, slots, emits }) => {
|
|
return !!props.length || !!slots.length || !!emits.length
|
|
})
|
|
|
|
writeFileSync(join(__dirname, 'diff.json'), JSON.stringify(diff, null, ' '), 'utf8')
|
|
}
|
|
|
|
if (require.main === module) {
|
|
writeDiffFile()
|
|
}
|