You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
546 lines
18 KiB
546 lines
18 KiB
1 year ago
|
'use strict';
|
||
|
|
|
||
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
|
||
|
|
var MagicString = require('magic-string');
|
||
|
|
var estreeWalker = require('estree-walker');
|
||
|
|
var compilerCore = require('@vue/compiler-core');
|
||
|
|
var parser = require('@babel/parser');
|
||
|
|
var shared = require('@vue/shared');
|
||
|
|
|
||
|
|
const CONVERT_SYMBOL = "$";
|
||
|
|
const ESCAPE_SYMBOL = "$$";
|
||
|
|
const IMPORT_SOURCE = "vue/macros";
|
||
|
|
const shorthands = ["ref", "computed", "shallowRef", "toRef", "customRef"];
|
||
|
|
const transformCheckRE = /[^\w]\$(?:\$|ref|computed|shallowRef)?\s*(\(|\<)/;
|
||
|
|
function shouldTransform(src) {
|
||
|
|
return transformCheckRE.test(src);
|
||
|
|
}
|
||
|
|
function transform(src, {
|
||
|
|
filename,
|
||
|
|
sourceMap,
|
||
|
|
parserPlugins,
|
||
|
|
importHelpersFrom = "vue"
|
||
|
|
} = {}) {
|
||
|
|
const plugins = parserPlugins || [];
|
||
|
|
if (filename) {
|
||
|
|
if (/\.tsx?$/.test(filename)) {
|
||
|
|
plugins.push("typescript");
|
||
|
|
}
|
||
|
|
if (filename.endsWith("x")) {
|
||
|
|
plugins.push("jsx");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const ast = parser.parse(src, {
|
||
|
|
sourceType: "module",
|
||
|
|
plugins
|
||
|
|
});
|
||
|
|
const s = new MagicString(src);
|
||
|
|
const res = transformAST(ast.program, s, 0);
|
||
|
|
if (res.importedHelpers.length) {
|
||
|
|
s.prepend(
|
||
|
|
`import { ${res.importedHelpers.map((h) => `${h} as _${h}`).join(", ")} } from '${importHelpersFrom}'
|
||
|
|
`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
...res,
|
||
|
|
code: s.toString(),
|
||
|
|
map: sourceMap ? s.generateMap({
|
||
|
|
source: filename,
|
||
|
|
hires: true,
|
||
|
|
includeContent: true
|
||
|
|
}) : null
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function transformAST(ast, s, offset = 0, knownRefs, knownProps) {
|
||
|
|
warnExperimental();
|
||
|
|
const userImports = /* @__PURE__ */ Object.create(null);
|
||
|
|
for (const node of ast.body) {
|
||
|
|
if (node.type !== "ImportDeclaration")
|
||
|
|
continue;
|
||
|
|
walkImportDeclaration(node);
|
||
|
|
}
|
||
|
|
let convertSymbol;
|
||
|
|
let escapeSymbol;
|
||
|
|
for (const { local, imported, source, specifier } of Object.values(
|
||
|
|
userImports
|
||
|
|
)) {
|
||
|
|
if (source === IMPORT_SOURCE) {
|
||
|
|
if (imported === ESCAPE_SYMBOL) {
|
||
|
|
escapeSymbol = local;
|
||
|
|
} else if (imported === CONVERT_SYMBOL) {
|
||
|
|
convertSymbol = local;
|
||
|
|
} else if (imported !== local) {
|
||
|
|
error(
|
||
|
|
`macro imports for ref-creating methods do not support aliasing.`,
|
||
|
|
specifier
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!convertSymbol && !userImports[CONVERT_SYMBOL]) {
|
||
|
|
convertSymbol = CONVERT_SYMBOL;
|
||
|
|
}
|
||
|
|
if (!escapeSymbol && !userImports[ESCAPE_SYMBOL]) {
|
||
|
|
escapeSymbol = ESCAPE_SYMBOL;
|
||
|
|
}
|
||
|
|
const importedHelpers = /* @__PURE__ */ new Set();
|
||
|
|
const rootScope = {};
|
||
|
|
const scopeStack = [rootScope];
|
||
|
|
let currentScope = rootScope;
|
||
|
|
let escapeScope;
|
||
|
|
const excludedIds = /* @__PURE__ */ new WeakSet();
|
||
|
|
const parentStack = [];
|
||
|
|
const propsLocalToPublicMap = /* @__PURE__ */ Object.create(null);
|
||
|
|
if (knownRefs) {
|
||
|
|
for (const key of knownRefs) {
|
||
|
|
rootScope[key] = {};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (knownProps) {
|
||
|
|
for (const key in knownProps) {
|
||
|
|
const { local, isConst } = knownProps[key];
|
||
|
|
rootScope[local] = {
|
||
|
|
isProp: true,
|
||
|
|
isConst: !!isConst
|
||
|
|
};
|
||
|
|
propsLocalToPublicMap[local] = key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function walkImportDeclaration(node) {
|
||
|
|
const source = node.source.value;
|
||
|
|
if (source === IMPORT_SOURCE) {
|
||
|
|
s.remove(node.start + offset, node.end + offset);
|
||
|
|
}
|
||
|
|
for (const specifier of node.specifiers) {
|
||
|
|
const local = specifier.local.name;
|
||
|
|
const imported = specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name || "default";
|
||
|
|
userImports[local] = {
|
||
|
|
source,
|
||
|
|
local,
|
||
|
|
imported,
|
||
|
|
specifier
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function isRefCreationCall(callee) {
|
||
|
|
if (!convertSymbol || currentScope[convertSymbol] !== void 0) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (callee === convertSymbol) {
|
||
|
|
return convertSymbol;
|
||
|
|
}
|
||
|
|
if (callee[0] === "$" && shorthands.includes(callee.slice(1))) {
|
||
|
|
return callee;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
function error(msg, node) {
|
||
|
|
const e = new Error(msg);
|
||
|
|
e.node = node;
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
function helper(msg) {
|
||
|
|
importedHelpers.add(msg);
|
||
|
|
return `_${msg}`;
|
||
|
|
}
|
||
|
|
function registerBinding(id, binding) {
|
||
|
|
excludedIds.add(id);
|
||
|
|
if (currentScope) {
|
||
|
|
currentScope[id.name] = binding ? binding : false;
|
||
|
|
} else {
|
||
|
|
error(
|
||
|
|
"registerBinding called without active scope, something is wrong.",
|
||
|
|
id
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const registerRefBinding = (id, isConst = false) => registerBinding(id, { isConst });
|
||
|
|
let tempVarCount = 0;
|
||
|
|
function genTempVar() {
|
||
|
|
return `__$temp_${++tempVarCount}`;
|
||
|
|
}
|
||
|
|
function snip(node) {
|
||
|
|
return s.original.slice(node.start + offset, node.end + offset);
|
||
|
|
}
|
||
|
|
function walkScope(node, isRoot = false) {
|
||
|
|
for (const stmt of node.body) {
|
||
|
|
if (stmt.type === "VariableDeclaration") {
|
||
|
|
walkVariableDeclaration(stmt, isRoot);
|
||
|
|
} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
|
||
|
|
if (stmt.declare || !stmt.id)
|
||
|
|
continue;
|
||
|
|
registerBinding(stmt.id);
|
||
|
|
} else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
|
||
|
|
walkVariableDeclaration(stmt.left);
|
||
|
|
} else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") {
|
||
|
|
walkVariableDeclaration(stmt.declaration, isRoot);
|
||
|
|
} else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") {
|
||
|
|
walkVariableDeclaration(stmt.body, isRoot);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function walkVariableDeclaration(stmt, isRoot = false) {
|
||
|
|
if (stmt.declare) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (const decl of stmt.declarations) {
|
||
|
|
let refCall;
|
||
|
|
const isCall = decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier";
|
||
|
|
if (isCall && (refCall = isRefCreationCall(decl.init.callee.name))) {
|
||
|
|
processRefDeclaration(
|
||
|
|
refCall,
|
||
|
|
decl.id,
|
||
|
|
decl.init,
|
||
|
|
stmt.kind === "const"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
const isProps = isRoot && isCall && decl.init.callee.name === "defineProps";
|
||
|
|
for (const id of compilerCore.extractIdentifiers(decl.id)) {
|
||
|
|
if (isProps) {
|
||
|
|
excludedIds.add(id);
|
||
|
|
} else {
|
||
|
|
registerBinding(id);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function processRefDeclaration(method, id, call, isConst) {
|
||
|
|
excludedIds.add(call.callee);
|
||
|
|
if (method === convertSymbol) {
|
||
|
|
s.remove(call.callee.start + offset, call.callee.end + offset);
|
||
|
|
if (id.type === "Identifier") {
|
||
|
|
registerRefBinding(id, isConst);
|
||
|
|
} else if (id.type === "ObjectPattern") {
|
||
|
|
processRefObjectPattern(id, call, isConst);
|
||
|
|
} else if (id.type === "ArrayPattern") {
|
||
|
|
processRefArrayPattern(id, call, isConst);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (id.type === "Identifier") {
|
||
|
|
registerRefBinding(id, isConst);
|
||
|
|
s.overwrite(
|
||
|
|
call.start + offset,
|
||
|
|
call.start + method.length + offset,
|
||
|
|
helper(method.slice(1))
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
error(`${method}() cannot be used with destructure patterns.`, call);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function processRefObjectPattern(pattern, call, isConst, tempVar, path = []) {
|
||
|
|
if (!tempVar) {
|
||
|
|
tempVar = genTempVar();
|
||
|
|
s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
|
||
|
|
}
|
||
|
|
let nameId;
|
||
|
|
for (const p of pattern.properties) {
|
||
|
|
let key;
|
||
|
|
let defaultValue;
|
||
|
|
if (p.type === "ObjectProperty") {
|
||
|
|
if (p.key.start === p.value.start) {
|
||
|
|
nameId = p.key;
|
||
|
|
if (p.value.type === "Identifier") {
|
||
|
|
excludedIds.add(p.value);
|
||
|
|
} else if (p.value.type === "AssignmentPattern" && p.value.left.type === "Identifier") {
|
||
|
|
excludedIds.add(p.value.left);
|
||
|
|
defaultValue = p.value.right;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
key = p.computed ? p.key : p.key.name;
|
||
|
|
if (p.value.type === "Identifier") {
|
||
|
|
nameId = p.value;
|
||
|
|
} else if (p.value.type === "ObjectPattern") {
|
||
|
|
processRefObjectPattern(p.value, call, isConst, tempVar, [
|
||
|
|
...path,
|
||
|
|
key
|
||
|
|
]);
|
||
|
|
} else if (p.value.type === "ArrayPattern") {
|
||
|
|
processRefArrayPattern(p.value, call, isConst, tempVar, [
|
||
|
|
...path,
|
||
|
|
key
|
||
|
|
]);
|
||
|
|
} else if (p.value.type === "AssignmentPattern") {
|
||
|
|
if (p.value.left.type === "Identifier") {
|
||
|
|
nameId = p.value.left;
|
||
|
|
defaultValue = p.value.right;
|
||
|
|
} else if (p.value.left.type === "ObjectPattern") {
|
||
|
|
processRefObjectPattern(p.value.left, call, isConst, tempVar, [
|
||
|
|
...path,
|
||
|
|
[key, p.value.right]
|
||
|
|
]);
|
||
|
|
} else if (p.value.left.type === "ArrayPattern") {
|
||
|
|
processRefArrayPattern(p.value.left, call, isConst, tempVar, [
|
||
|
|
...path,
|
||
|
|
[key, p.value.right]
|
||
|
|
]);
|
||
|
|
} else ;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
error(`reactivity destructure does not support rest elements.`, p);
|
||
|
|
}
|
||
|
|
if (nameId) {
|
||
|
|
registerRefBinding(nameId, isConst);
|
||
|
|
const source = pathToString(tempVar, path);
|
||
|
|
const keyStr = shared.isString(key) ? `'${key}'` : key ? snip(key) : `'${nameId.name}'`;
|
||
|
|
const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
|
||
|
|
s.appendLeft(
|
||
|
|
call.end + offset,
|
||
|
|
`,
|
||
|
|
${nameId.name} = ${helper(
|
||
|
|
"toRef"
|
||
|
|
)}(${source}, ${keyStr}${defaultStr})`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (nameId) {
|
||
|
|
s.appendLeft(call.end + offset, ";");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function processRefArrayPattern(pattern, call, isConst, tempVar, path = []) {
|
||
|
|
if (!tempVar) {
|
||
|
|
tempVar = genTempVar();
|
||
|
|
s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
|
||
|
|
}
|
||
|
|
let nameId;
|
||
|
|
for (let i = 0; i < pattern.elements.length; i++) {
|
||
|
|
const e = pattern.elements[i];
|
||
|
|
if (!e)
|
||
|
|
continue;
|
||
|
|
let defaultValue;
|
||
|
|
if (e.type === "Identifier") {
|
||
|
|
nameId = e;
|
||
|
|
} else if (e.type === "AssignmentPattern") {
|
||
|
|
nameId = e.left;
|
||
|
|
defaultValue = e.right;
|
||
|
|
} else if (e.type === "RestElement") {
|
||
|
|
error(`reactivity destructure does not support rest elements.`, e);
|
||
|
|
} else if (e.type === "ObjectPattern") {
|
||
|
|
processRefObjectPattern(e, call, isConst, tempVar, [...path, i]);
|
||
|
|
} else if (e.type === "ArrayPattern") {
|
||
|
|
processRefArrayPattern(e, call, isConst, tempVar, [...path, i]);
|
||
|
|
}
|
||
|
|
if (nameId) {
|
||
|
|
registerRefBinding(nameId, isConst);
|
||
|
|
const source = pathToString(tempVar, path);
|
||
|
|
const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
|
||
|
|
s.appendLeft(
|
||
|
|
call.end + offset,
|
||
|
|
`,
|
||
|
|
${nameId.name} = ${helper(
|
||
|
|
"toRef"
|
||
|
|
)}(${source}, ${i}${defaultStr})`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (nameId) {
|
||
|
|
s.appendLeft(call.end + offset, ";");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function pathToString(source, path) {
|
||
|
|
if (path.length) {
|
||
|
|
for (const seg of path) {
|
||
|
|
if (shared.isArray(seg)) {
|
||
|
|
source = `(${source}${segToString(seg[0])} || ${snip(seg[1])})`;
|
||
|
|
} else {
|
||
|
|
source += segToString(seg);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
function segToString(seg) {
|
||
|
|
if (typeof seg === "number") {
|
||
|
|
return `[${seg}]`;
|
||
|
|
} else if (typeof seg === "string") {
|
||
|
|
return `.${seg}`;
|
||
|
|
} else {
|
||
|
|
return snip(seg);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function rewriteId(scope, id, parent, parentStack2) {
|
||
|
|
if (shared.hasOwn(scope, id.name)) {
|
||
|
|
const binding = scope[id.name];
|
||
|
|
if (binding) {
|
||
|
|
if (binding.isConst && (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression")) {
|
||
|
|
error(`Assignment to constant variable.`, id);
|
||
|
|
}
|
||
|
|
const { isProp } = binding;
|
||
|
|
if (compilerCore.isStaticProperty(parent) && parent.shorthand) {
|
||
|
|
if (!parent.inPattern || compilerCore.isInDestructureAssignment(parent, parentStack2)) {
|
||
|
|
if (isProp) {
|
||
|
|
if (escapeScope) {
|
||
|
|
registerEscapedPropBinding(id);
|
||
|
|
s.appendLeft(
|
||
|
|
id.end + offset,
|
||
|
|
`: __props_${propsLocalToPublicMap[id.name]}`
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
s.appendLeft(
|
||
|
|
id.end + offset,
|
||
|
|
`: ${shared.genPropsAccessExp(propsLocalToPublicMap[id.name])}`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
s.appendLeft(id.end + offset, `: ${id.name}.value`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (isProp) {
|
||
|
|
if (escapeScope) {
|
||
|
|
registerEscapedPropBinding(id);
|
||
|
|
s.overwrite(
|
||
|
|
id.start + offset,
|
||
|
|
id.end + offset,
|
||
|
|
`__props_${propsLocalToPublicMap[id.name]}`
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
s.overwrite(
|
||
|
|
id.start + offset,
|
||
|
|
id.end + offset,
|
||
|
|
shared.genPropsAccessExp(propsLocalToPublicMap[id.name])
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
s.appendLeft(id.end + offset, ".value");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const propBindingRefs = {};
|
||
|
|
function registerEscapedPropBinding(id) {
|
||
|
|
if (!propBindingRefs.hasOwnProperty(id.name)) {
|
||
|
|
propBindingRefs[id.name] = true;
|
||
|
|
const publicKey = propsLocalToPublicMap[id.name];
|
||
|
|
s.prependRight(
|
||
|
|
offset,
|
||
|
|
`const __props_${publicKey} = ${helper(
|
||
|
|
`toRef`
|
||
|
|
)}(__props, '${publicKey}');
|
||
|
|
`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
walkScope(ast, true);
|
||
|
|
estreeWalker.walk(ast, {
|
||
|
|
enter(node, parent) {
|
||
|
|
parent && parentStack.push(parent);
|
||
|
|
if (compilerCore.isFunctionType(node)) {
|
||
|
|
scopeStack.push(currentScope = {});
|
||
|
|
compilerCore.walkFunctionParams(node, registerBinding);
|
||
|
|
if (node.body.type === "BlockStatement") {
|
||
|
|
walkScope(node.body);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (node.type === "CatchClause") {
|
||
|
|
scopeStack.push(currentScope = {});
|
||
|
|
if (node.param && node.param.type === "Identifier") {
|
||
|
|
registerBinding(node.param);
|
||
|
|
}
|
||
|
|
walkScope(node.body);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (node.type === "BlockStatement" && !compilerCore.isFunctionType(parent)) {
|
||
|
|
scopeStack.push(currentScope = {});
|
||
|
|
walkScope(node);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (parent && parent.type.startsWith("TS") && parent.type !== "TSAsExpression" && parent.type !== "TSNonNullExpression" && parent.type !== "TSTypeAssertion") {
|
||
|
|
return this.skip();
|
||
|
|
}
|
||
|
|
if (node.type === "Identifier") {
|
||
|
|
const binding = rootScope[node.name];
|
||
|
|
if (
|
||
|
|
// if inside $$(), skip unless this is a destructured prop binding
|
||
|
|
!(escapeScope && (!binding || !binding.isProp)) && compilerCore.isReferencedIdentifier(node, parent, parentStack) && !excludedIds.has(node)
|
||
|
|
) {
|
||
|
|
let i = scopeStack.length;
|
||
|
|
while (i--) {
|
||
|
|
if (rewriteId(scopeStack[i], node, parent, parentStack)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (node.type === "CallExpression" && node.callee.type === "Identifier") {
|
||
|
|
const callee = node.callee.name;
|
||
|
|
const refCall = isRefCreationCall(callee);
|
||
|
|
if (refCall && (!parent || parent.type !== "VariableDeclarator")) {
|
||
|
|
return error(
|
||
|
|
`${refCall} can only be used as the initializer of a variable declaration.`,
|
||
|
|
node
|
||
|
|
);
|
||
|
|
}
|
||
|
|
if (escapeSymbol && currentScope[escapeSymbol] === void 0 && callee === escapeSymbol) {
|
||
|
|
escapeScope = node;
|
||
|
|
s.remove(node.callee.start + offset, node.callee.end + offset);
|
||
|
|
if ((parent == null ? void 0 : parent.type) === "ExpressionStatement") {
|
||
|
|
let i = (node.leadingComments ? node.leadingComments[0].start : node.start) + offset;
|
||
|
|
while (i--) {
|
||
|
|
const char = s.original.charAt(i);
|
||
|
|
if (char === "\n") {
|
||
|
|
s.prependRight(node.start + offset, ";");
|
||
|
|
break;
|
||
|
|
} else if (!/\s/.test(char)) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
leave(node, parent) {
|
||
|
|
parent && parentStack.pop();
|
||
|
|
if (node.type === "BlockStatement" && !compilerCore.isFunctionType(parent) || compilerCore.isFunctionType(node)) {
|
||
|
|
scopeStack.pop();
|
||
|
|
currentScope = scopeStack[scopeStack.length - 1] || null;
|
||
|
|
}
|
||
|
|
if (node === escapeScope) {
|
||
|
|
escapeScope = void 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return {
|
||
|
|
rootRefs: Object.keys(rootScope).filter((key) => {
|
||
|
|
const binding = rootScope[key];
|
||
|
|
return binding && !binding.isProp;
|
||
|
|
}),
|
||
|
|
importedHelpers: [...importedHelpers]
|
||
|
|
};
|
||
|
|
}
|
||
|
|
const hasWarned = {};
|
||
|
|
function warnExperimental() {
|
||
|
|
if (typeof window !== "undefined") {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
warnOnce(
|
||
|
|
`Reactivity Transform was an experimental feature and has now been deprecated. It will be removed from Vue core in 3.4. If you intend to continue using it, switch to https://vue-macros.sxzz.moe/features/reactivity-transform.html.
|
||
|
|
See reason for deprecation here: https://github.com/vuejs/rfcs/discussions/369#discussioncomment-5059028`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
function warnOnce(msg) {
|
||
|
|
const isNodeProd = typeof process !== "undefined" && process.env.NODE_ENV === "production";
|
||
|
|
if (!isNodeProd && true && !hasWarned[msg]) {
|
||
|
|
hasWarned[msg] = true;
|
||
|
|
warn(msg);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function warn(msg) {
|
||
|
|
console.warn(
|
||
|
|
`\x1B[1m\x1B[33m[@vue/reactivity-transform]\x1B[0m\x1B[33m ${msg}\x1B[0m
|
||
|
|
`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
exports.shouldTransform = shouldTransform;
|
||
|
|
exports.transform = transform;
|
||
|
|
exports.transformAST = transformAST;
|