const t = require('@babel/types')
|
const traverse = require('@babel/traverse').default
|
|
const {
|
VAR_ROOT,
|
IDENTIFIER_METHOD,
|
IDENTIFIER_FILTER,
|
IDENTIFIER_GLOBAL,
|
METHOD_RENDER_LIST
|
} = require('../../constants')
|
|
function isMatch (name, forItem, forIndex) {
|
return name === forItem || name === forIndex
|
}
|
|
function findScoped (path, test, state) {
|
if (!path) {
|
return state
|
}
|
const scoped = state.scoped.find(scoped => {
|
const {
|
forItem,
|
forIndex,
|
path: listPath
|
} = scoped
|
const funPath = path.findParent(path =>
|
path.isFunctionExpression() &&
|
t.isCallExpression(path.parentPath) &&
|
path.parentPath.node.callee.name === METHOD_RENDER_LIST
|
)
|
if (funPath && funPath.parentPath === listPath) {
|
// TODO 为兼容历史结构仅在当前 list 父级存在 v-if 返回
|
const parent = listPath.findParent(path => path.isFunctionExpression() || path.isConditionalExpression())
|
if (parent && parent.isConditionalExpression()) {
|
return true
|
}
|
} else {
|
return false
|
}
|
let match = false
|
path.traverse({
|
noScope: true,
|
Identifier (path) {
|
if (!match && path.key !== 'key' && (path.key !== 'property' || path.parent.computed)) {
|
match = isMatch(path.node.name, forItem, forIndex)
|
if (match) {
|
path.stop()
|
}
|
}
|
}
|
})
|
if (!match && test) {
|
traverse(t.arrayExpression([test]), {
|
noScope: true,
|
Identifier (path) {
|
if (!match && path.key !== 'key' && (path.key !== 'property' || path.parent.computed)) {
|
const node = path.node
|
match = isMatch(node.name, forItem, forIndex) || scoped.declarationArray.find(({ declarations }) => declarations.find(({ id }) => id === node))
|
if (match) {
|
path.stop()
|
}
|
}
|
}
|
})
|
}
|
return match
|
})
|
if (!scoped && state.scoped.length > 1) {
|
return state.scoped[1] // 取父
|
}
|
return scoped || state
|
}
|
|
function findTest (path, state) {
|
let tests
|
if (path) {
|
while (path.parentPath && path.key !== 'body') {
|
if (path.key === 'consequent' || path.key === 'alternate') {
|
const testOrig = path.container.test
|
let test = t.arrayExpression([t.cloneDeep(testOrig)])
|
traverse(test, {
|
noScope: true,
|
MemberExpression (memberExpressionPath) {
|
const names = state.scoped.map(scoped => scoped.forItem)
|
const node = memberExpressionPath.node
|
const objectName = node.object.name
|
const property = node.property
|
const propertyName = property.name
|
if (objectName === VAR_ROOT || (names.includes(objectName) && (propertyName === IDENTIFIER_METHOD || propertyName === IDENTIFIER_FILTER || propertyName === IDENTIFIER_GLOBAL))) {
|
const array = []
|
let tempPath = memberExpressionPath
|
while (tempPath.parentPath) {
|
const key = tempPath.key
|
array.unshift(typeof key === 'number' ? `[${key}]` : `.${key}`)
|
tempPath = tempPath.parentPath
|
}
|
memberExpressionPath.replaceWith(path.parentPath.get('test' + array.join('')).node.property)
|
}
|
}
|
})
|
test = test.elements[0]
|
if (path.key === 'alternate') {
|
test = t.unaryExpression('!', test)
|
}
|
tests = tests ? t.logicalExpression('&&', test, tests) : test
|
}
|
path = path.parentPath
|
}
|
}
|
return tests
|
}
|
|
module.exports = function getMemberExpr (path, name, init, state, variableDeclaration = true) {
|
const test = findTest(path, state)
|
const scoped = findScoped(path, test, state)
|
|
if (!variableDeclaration) {
|
scoped.declarationArray.push(t.expressionStatement(init))
|
return
|
}
|
|
const identifier = t.identifier(name)
|
|
scoped.propertyArray.push(t.objectProperty(identifier, identifier))
|
scoped.declarationArray.push(
|
t.variableDeclaration('var', [t.variableDeclarator(identifier, test ? t.conditionalExpression(test, init, t.nullLiteral()) : init)])
|
)
|
|
state.identifierArray.push(identifier)
|
|
const contextIdentifier = t.identifier(scoped.context)
|
contextIdentifier.$mpProcessed = true
|
return t.memberExpression(contextIdentifier, identifier)
|
}
|
