77b4d10af8
Standardize settings file naming and relocate documentation files Fix code quality violations from rsx:check Reorganize user_management directory into logical subdirectories Move Quill Bundle to core and align with Tom Select pattern Simplify Site Settings page to focus on core site information Complete Phase 5: Multi-tenant authentication with login flow and site selection Add route query parameter rule and synchronize filename validation logic Fix critical bug in UpdateNpmCommand causing missing JavaScript stubs Implement filename convention rule and resolve VS Code auto-rename conflict Implement js-sanitizer RPC server to eliminate 900+ Node.js process spawns Implement RPC server architecture for JavaScript parsing WIP: Add RPC server infrastructure for JS parsing (partial implementation) Update jqhtml terminology from destroy to stop, fix datagrid DOM preservation Add JQHTML-CLASS-01 rule and fix redundant class names Improve code quality rules and resolve violations Remove legacy fatal error format in favor of unified 'fatal' error type Filter internal keys from window.rsxapp output Update button styling and comprehensive form/modal documentation Add conditional fly-in animation for modals Fix non-deterministic bundle compilation 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
1053 lines
40 KiB
JavaScript
Executable File
1053 lines
40 KiB
JavaScript
Executable File
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.buildCheckInRHS = buildCheckInRHS;
|
|
exports.buildFieldsInitNodes = buildFieldsInitNodes;
|
|
exports.buildPrivateNamesMap = buildPrivateNamesMap;
|
|
exports.buildPrivateNamesNodes = buildPrivateNamesNodes;
|
|
exports.privateNameVisitorFactory = privateNameVisitorFactory;
|
|
exports.transformPrivateNamesUsage = transformPrivateNamesUsage;
|
|
var _core = require("@babel/core");
|
|
var _traverse = require("@babel/traverse");
|
|
var _helperReplaceSupers = require("@babel/helper-replace-supers");
|
|
var _helperMemberExpressionToFunctions = require("@babel/helper-member-expression-to-functions");
|
|
var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-expression");
|
|
var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure");
|
|
var _helperSkipTransparentExpressionWrappers = require("@babel/helper-skip-transparent-expression-wrappers");
|
|
var ts = require("./typescript.js");
|
|
{
|
|
var newHelpers = file => {
|
|
;
|
|
return file.availableHelper("classPrivateFieldGet2");
|
|
};
|
|
}
|
|
function buildPrivateNamesMap(className, privateFieldsAsSymbolsOrProperties, props, file) {
|
|
const privateNamesMap = new Map();
|
|
let classBrandId;
|
|
for (const prop of props) {
|
|
if (prop.isPrivate()) {
|
|
const {
|
|
name
|
|
} = prop.node.key.id;
|
|
let update = privateNamesMap.get(name);
|
|
if (!update) {
|
|
const isMethod = !prop.isProperty();
|
|
const isStatic = prop.node.static;
|
|
let initAdded = false;
|
|
let id;
|
|
if (!privateFieldsAsSymbolsOrProperties && newHelpers(file) && isMethod && !isStatic) {
|
|
initAdded = !!classBrandId;
|
|
classBrandId != null ? classBrandId : classBrandId = prop.scope.generateUidIdentifier(`${className}_brand`);
|
|
id = classBrandId;
|
|
} else {
|
|
id = prop.scope.generateUidIdentifier(name);
|
|
}
|
|
update = {
|
|
id,
|
|
static: isStatic,
|
|
method: isMethod,
|
|
initAdded
|
|
};
|
|
privateNamesMap.set(name, update);
|
|
}
|
|
if (prop.isClassPrivateMethod()) {
|
|
if (prop.node.kind === "get") {
|
|
const {
|
|
body
|
|
} = prop.node.body;
|
|
let $;
|
|
if (body.length === 1 && _core.types.isReturnStatement($ = body[0]) && _core.types.isCallExpression($ = $.argument) && $.arguments.length === 1 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($ = $.callee)) {
|
|
update.getId = _core.types.cloneNode($);
|
|
update.getterDeclared = true;
|
|
} else {
|
|
update.getId = prop.scope.generateUidIdentifier(`get_${name}`);
|
|
}
|
|
} else if (prop.node.kind === "set") {
|
|
const {
|
|
params
|
|
} = prop.node;
|
|
const {
|
|
body
|
|
} = prop.node.body;
|
|
let $;
|
|
if (body.length === 1 && _core.types.isExpressionStatement($ = body[0]) && _core.types.isCallExpression($ = $.expression) && $.arguments.length === 2 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($.arguments[1], {
|
|
name: params[0].name
|
|
}) && _core.types.isIdentifier($ = $.callee)) {
|
|
update.setId = _core.types.cloneNode($);
|
|
update.setterDeclared = true;
|
|
} else {
|
|
update.setId = prop.scope.generateUidIdentifier(`set_${name}`);
|
|
}
|
|
} else if (prop.node.kind === "method") {
|
|
update.methodId = prop.scope.generateUidIdentifier(name);
|
|
}
|
|
}
|
|
privateNamesMap.set(name, update);
|
|
}
|
|
}
|
|
return privateNamesMap;
|
|
}
|
|
function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, privateFieldsAsSymbols, state) {
|
|
const initNodes = [];
|
|
const injectedIds = new Set();
|
|
for (const [name, value] of privateNamesMap) {
|
|
const {
|
|
static: isStatic,
|
|
method: isMethod,
|
|
getId,
|
|
setId
|
|
} = value;
|
|
const isGetterOrSetter = getId || setId;
|
|
const id = _core.types.cloneNode(value.id);
|
|
let init;
|
|
if (privateFieldsAsProperties) {
|
|
init = _core.types.callExpression(state.addHelper("classPrivateFieldLooseKey"), [_core.types.stringLiteral(name)]);
|
|
} else if (privateFieldsAsSymbols) {
|
|
init = _core.types.callExpression(_core.types.identifier("Symbol"), [_core.types.stringLiteral(name)]);
|
|
} else if (!isStatic) {
|
|
if (injectedIds.has(id.name)) continue;
|
|
injectedIds.add(id.name);
|
|
init = _core.types.newExpression(_core.types.identifier(isMethod && (!isGetterOrSetter || newHelpers(state)) ? "WeakSet" : "WeakMap"), []);
|
|
}
|
|
if (init) {
|
|
if (!privateFieldsAsSymbols) {
|
|
(0, _helperAnnotateAsPure.default)(init);
|
|
}
|
|
initNodes.push(_core.template.statement.ast`var ${id} = ${init}`);
|
|
}
|
|
}
|
|
return initNodes;
|
|
}
|
|
function privateNameVisitorFactory(visitor) {
|
|
const nestedVisitor = _traverse.visitors.environmentVisitor(Object.assign({}, visitor));
|
|
const privateNameVisitor = Object.assign({}, visitor, {
|
|
Class(path) {
|
|
const {
|
|
privateNamesMap
|
|
} = this;
|
|
const body = path.get("body.body");
|
|
const visiblePrivateNames = new Map(privateNamesMap);
|
|
const redeclared = [];
|
|
for (const prop of body) {
|
|
if (!prop.isPrivate()) continue;
|
|
const {
|
|
name
|
|
} = prop.node.key.id;
|
|
visiblePrivateNames.delete(name);
|
|
redeclared.push(name);
|
|
}
|
|
if (!redeclared.length) {
|
|
return;
|
|
}
|
|
path.get("body").traverse(nestedVisitor, Object.assign({}, this, {
|
|
redeclared
|
|
}));
|
|
path.traverse(privateNameVisitor, Object.assign({}, this, {
|
|
privateNamesMap: visiblePrivateNames
|
|
}));
|
|
path.skipKey("body");
|
|
}
|
|
});
|
|
return privateNameVisitor;
|
|
}
|
|
const privateNameVisitor = privateNameVisitorFactory({
|
|
PrivateName(path, {
|
|
noDocumentAll
|
|
}) {
|
|
const {
|
|
privateNamesMap,
|
|
redeclared
|
|
} = this;
|
|
const {
|
|
node,
|
|
parentPath
|
|
} = path;
|
|
if (!parentPath.isMemberExpression({
|
|
property: node
|
|
}) && !parentPath.isOptionalMemberExpression({
|
|
property: node
|
|
})) {
|
|
return;
|
|
}
|
|
const {
|
|
name
|
|
} = node.id;
|
|
if (!privateNamesMap.has(name)) return;
|
|
if (redeclared != null && redeclared.includes(name)) return;
|
|
this.handle(parentPath, noDocumentAll);
|
|
}
|
|
});
|
|
function unshadow(name, scope, innerBinding) {
|
|
while ((_scope = scope) != null && _scope.hasBinding(name) && !scope.bindingIdentifierEquals(name, innerBinding)) {
|
|
var _scope;
|
|
scope.rename(name);
|
|
scope = scope.parent;
|
|
}
|
|
}
|
|
function buildCheckInRHS(rhs, file, inRHSIsObject) {
|
|
if (inRHSIsObject || !(file.availableHelper != null && file.availableHelper("checkInRHS"))) return rhs;
|
|
return _core.types.callExpression(file.addHelper("checkInRHS"), [rhs]);
|
|
}
|
|
const privateInVisitor = privateNameVisitorFactory({
|
|
BinaryExpression(path, {
|
|
file
|
|
}) {
|
|
const {
|
|
operator,
|
|
left,
|
|
right
|
|
} = path.node;
|
|
if (operator !== "in") return;
|
|
if (!_core.types.isPrivateName(left)) return;
|
|
const {
|
|
privateFieldsAsProperties,
|
|
privateNamesMap,
|
|
redeclared
|
|
} = this;
|
|
const {
|
|
name
|
|
} = left.id;
|
|
if (!privateNamesMap.has(name)) return;
|
|
if (redeclared != null && redeclared.includes(name)) return;
|
|
unshadow(this.classRef.name, path.scope, this.innerBinding);
|
|
if (privateFieldsAsProperties) {
|
|
const {
|
|
id
|
|
} = privateNamesMap.get(name);
|
|
path.replaceWith(_core.template.expression.ast`
|
|
Object.prototype.hasOwnProperty.call(${buildCheckInRHS(right, file)}, ${_core.types.cloneNode(id)})
|
|
`);
|
|
return;
|
|
}
|
|
const {
|
|
id,
|
|
static: isStatic
|
|
} = privateNamesMap.get(name);
|
|
if (isStatic) {
|
|
path.replaceWith(_core.template.expression.ast`${buildCheckInRHS(right, file)} === ${_core.types.cloneNode(this.classRef)}`);
|
|
return;
|
|
}
|
|
path.replaceWith(_core.template.expression.ast`${_core.types.cloneNode(id)}.has(${buildCheckInRHS(right, file)})`);
|
|
}
|
|
});
|
|
function readOnlyError(file, name) {
|
|
return _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)]);
|
|
}
|
|
function writeOnlyError(file, name) {
|
|
if (!file.availableHelper("writeOnlyError")) {
|
|
console.warn(`@babel/helpers is outdated, update it to silence this warning.`);
|
|
return _core.types.buildUndefinedNode();
|
|
}
|
|
return _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name}`)]);
|
|
}
|
|
function buildStaticPrivateFieldAccess(expr, noUninitializedPrivateFieldAccess) {
|
|
if (noUninitializedPrivateFieldAccess) return expr;
|
|
return _core.types.memberExpression(expr, _core.types.identifier("_"));
|
|
}
|
|
function autoInherits(fn) {
|
|
return function (member) {
|
|
return _core.types.inherits(fn.apply(this, arguments), member.node);
|
|
};
|
|
}
|
|
const privateNameHandlerSpec = {
|
|
memoise(member, count) {
|
|
const {
|
|
scope
|
|
} = member;
|
|
const {
|
|
object
|
|
} = member.node;
|
|
const memo = scope.maybeGenerateMemoised(object);
|
|
if (!memo) {
|
|
return;
|
|
}
|
|
this.memoiser.set(object, memo, count);
|
|
},
|
|
receiver(member) {
|
|
const {
|
|
object
|
|
} = member.node;
|
|
if (this.memoiser.has(object)) {
|
|
return _core.types.cloneNode(this.memoiser.get(object));
|
|
}
|
|
return _core.types.cloneNode(object);
|
|
},
|
|
get: autoInherits(function (member) {
|
|
const {
|
|
classRef,
|
|
privateNamesMap,
|
|
file,
|
|
innerBinding,
|
|
noUninitializedPrivateFieldAccess
|
|
} = this;
|
|
const privateName = member.node.property;
|
|
const {
|
|
name
|
|
} = privateName.id;
|
|
const {
|
|
id,
|
|
static: isStatic,
|
|
method: isMethod,
|
|
methodId,
|
|
getId,
|
|
setId
|
|
} = privateNamesMap.get(name);
|
|
const isGetterOrSetter = getId || setId;
|
|
const cloneId = id => _core.types.inherits(_core.types.cloneNode(id), privateName);
|
|
if (isStatic) {
|
|
unshadow(classRef.name, member.scope, innerBinding);
|
|
if (!newHelpers(file)) {
|
|
const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet";
|
|
return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), cloneId(id)]);
|
|
}
|
|
const receiver = this.receiver(member);
|
|
const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name;
|
|
if (!isMethod) {
|
|
if (skipCheck) {
|
|
return buildStaticPrivateFieldAccess(cloneId(id), noUninitializedPrivateFieldAccess);
|
|
}
|
|
return buildStaticPrivateFieldAccess(_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, cloneId(id)]), noUninitializedPrivateFieldAccess);
|
|
}
|
|
if (getId) {
|
|
if (skipCheck) {
|
|
return _core.types.callExpression(cloneId(getId), [receiver]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(classRef), receiver, cloneId(getId)]);
|
|
}
|
|
if (setId) {
|
|
const err = _core.types.buildUndefinedNode();
|
|
if (skipCheck) return err;
|
|
return _core.types.sequenceExpression([_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), err]);
|
|
}
|
|
if (skipCheck) return cloneId(id);
|
|
return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, cloneId(id)]);
|
|
}
|
|
if (isMethod) {
|
|
if (isGetterOrSetter) {
|
|
if (!getId) {
|
|
return _core.types.sequenceExpression([this.receiver(member), writeOnlyError(file, name)]);
|
|
}
|
|
if (!newHelpers(file)) {
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), cloneId(id)]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(id), this.receiver(member), cloneId(getId)]);
|
|
}
|
|
if (!newHelpers(file)) {
|
|
return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), cloneId(methodId)]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(id), this.receiver(member), cloneId(methodId)]);
|
|
}
|
|
if (newHelpers(file)) {
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldGet2"), [cloneId(id), this.receiver(member)]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), cloneId(id)]);
|
|
}),
|
|
boundGet(member) {
|
|
this.memoise(member, 1);
|
|
return _core.types.callExpression(_core.types.memberExpression(this.get(member), _core.types.identifier("bind")), [this.receiver(member)]);
|
|
},
|
|
set: autoInherits(function (member, value) {
|
|
const {
|
|
classRef,
|
|
privateNamesMap,
|
|
file,
|
|
noUninitializedPrivateFieldAccess
|
|
} = this;
|
|
const privateName = member.node.property;
|
|
const {
|
|
name
|
|
} = privateName.id;
|
|
const {
|
|
id,
|
|
static: isStatic,
|
|
method: isMethod,
|
|
setId,
|
|
getId
|
|
} = privateNamesMap.get(name);
|
|
const isGetterOrSetter = getId || setId;
|
|
const cloneId = id => _core.types.inherits(_core.types.cloneNode(id), privateName);
|
|
if (isStatic) {
|
|
if (!newHelpers(file)) {
|
|
const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet";
|
|
return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), cloneId(id), value]);
|
|
}
|
|
const receiver = this.receiver(member);
|
|
const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name;
|
|
if (isMethod && !setId) {
|
|
const err = readOnlyError(file, name);
|
|
if (skipCheck) return _core.types.sequenceExpression([value, err]);
|
|
return _core.types.sequenceExpression([value, _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), readOnlyError(file, name)]);
|
|
}
|
|
if (setId) {
|
|
if (skipCheck) {
|
|
return _core.types.callExpression(_core.types.cloneNode(setId), [receiver, value]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(classRef), cloneId(setId), receiver, value]);
|
|
}
|
|
return _core.types.assignmentExpression("=", buildStaticPrivateFieldAccess(cloneId(id), noUninitializedPrivateFieldAccess), skipCheck ? value : _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, value]));
|
|
}
|
|
if (isMethod) {
|
|
if (setId) {
|
|
if (!newHelpers(file)) {
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), cloneId(id), value]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(id), cloneId(setId), this.receiver(member), value]);
|
|
}
|
|
return _core.types.sequenceExpression([this.receiver(member), value, readOnlyError(file, name)]);
|
|
}
|
|
if (newHelpers(file)) {
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldSet2"), [cloneId(id), this.receiver(member), value]);
|
|
}
|
|
return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), cloneId(id), value]);
|
|
}),
|
|
destructureSet(member) {
|
|
const {
|
|
classRef,
|
|
privateNamesMap,
|
|
file,
|
|
noUninitializedPrivateFieldAccess
|
|
} = this;
|
|
const privateName = member.node.property;
|
|
const {
|
|
name
|
|
} = privateName.id;
|
|
const {
|
|
id,
|
|
static: isStatic,
|
|
method: isMethod,
|
|
setId
|
|
} = privateNamesMap.get(name);
|
|
const cloneId = id => _core.types.inherits(_core.types.cloneNode(id), privateName);
|
|
if (!newHelpers(file)) {
|
|
if (isStatic) {
|
|
try {
|
|
var helper = file.addHelper("classStaticPrivateFieldDestructureSet");
|
|
} catch (_unused) {
|
|
throw new Error("Babel can not transpile `[C.#p] = [0]` with @babel/helpers < 7.13.10, \n" + "please update @babel/helpers to the latest version.");
|
|
}
|
|
return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), cloneId(id)]), _core.types.identifier("value"));
|
|
}
|
|
return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), cloneId(id)]), _core.types.identifier("value"));
|
|
}
|
|
if (isMethod && !setId) {
|
|
return _core.types.memberExpression(_core.types.sequenceExpression([member.node.object, readOnlyError(file, name)]), _core.types.identifier("_"));
|
|
}
|
|
if (isStatic && !isMethod) {
|
|
const getCall = this.get(member);
|
|
if (!noUninitializedPrivateFieldAccess || !_core.types.isCallExpression(getCall)) {
|
|
return getCall;
|
|
}
|
|
const ref = getCall.arguments.pop();
|
|
getCall.arguments.push(_core.template.expression.ast`(_) => ${ref} = _`);
|
|
return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), [getCall]), _core.types.identifier("_"));
|
|
}
|
|
const setCall = this.set(member, _core.types.identifier("_"));
|
|
if (!_core.types.isCallExpression(setCall) || !_core.types.isIdentifier(setCall.arguments[setCall.arguments.length - 1], {
|
|
name: "_"
|
|
})) {
|
|
throw member.buildCodeFrameError("Internal Babel error while compiling this code. This is a Babel bug. " + "Please report it at https://github.com/babel/babel/issues.");
|
|
}
|
|
let args;
|
|
if (_core.types.isMemberExpression(setCall.callee, {
|
|
computed: false
|
|
}) && _core.types.isIdentifier(setCall.callee.property) && setCall.callee.property.name === "call") {
|
|
args = [setCall.callee.object, _core.types.arrayExpression(setCall.arguments.slice(1, -1)), setCall.arguments[0]];
|
|
} else {
|
|
args = [setCall.callee, _core.types.arrayExpression(setCall.arguments.slice(0, -1))];
|
|
}
|
|
return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), args), _core.types.identifier("_"));
|
|
},
|
|
call(member, args) {
|
|
this.memoise(member, 1);
|
|
return (0, _helperOptimiseCallExpression.default)(this.get(member), this.receiver(member), args, false);
|
|
},
|
|
optionalCall(member, args) {
|
|
this.memoise(member, 1);
|
|
return (0, _helperOptimiseCallExpression.default)(this.get(member), this.receiver(member), args, true);
|
|
},
|
|
delete() {
|
|
throw new Error("Internal Babel error: deleting private elements is a parsing error.");
|
|
}
|
|
};
|
|
const privateNameHandlerLoose = {
|
|
get(member) {
|
|
const {
|
|
privateNamesMap,
|
|
file
|
|
} = this;
|
|
const {
|
|
object
|
|
} = member.node;
|
|
const {
|
|
name
|
|
} = member.node.property.id;
|
|
return _core.template.expression`BASE(REF, PROP)[PROP]`({
|
|
BASE: file.addHelper("classPrivateFieldLooseBase"),
|
|
REF: _core.types.cloneNode(object),
|
|
PROP: _core.types.cloneNode(privateNamesMap.get(name).id)
|
|
});
|
|
},
|
|
set() {
|
|
throw new Error("private name handler with loose = true don't need set()");
|
|
},
|
|
boundGet(member) {
|
|
return _core.types.callExpression(_core.types.memberExpression(this.get(member), _core.types.identifier("bind")), [_core.types.cloneNode(member.node.object)]);
|
|
},
|
|
simpleSet(member) {
|
|
return this.get(member);
|
|
},
|
|
destructureSet(member) {
|
|
return this.get(member);
|
|
},
|
|
call(member, args) {
|
|
return _core.types.callExpression(this.get(member), args);
|
|
},
|
|
optionalCall(member, args) {
|
|
return _core.types.optionalCallExpression(this.get(member), args, true);
|
|
},
|
|
delete() {
|
|
throw new Error("Internal Babel error: deleting private elements is a parsing error.");
|
|
}
|
|
};
|
|
function transformPrivateNamesUsage(ref, path, privateNamesMap, {
|
|
privateFieldsAsProperties,
|
|
noUninitializedPrivateFieldAccess,
|
|
noDocumentAll,
|
|
innerBinding
|
|
}, state) {
|
|
if (!privateNamesMap.size) return;
|
|
const body = path.get("body");
|
|
const handler = privateFieldsAsProperties ? privateNameHandlerLoose : privateNameHandlerSpec;
|
|
(0, _helperMemberExpressionToFunctions.default)(body, privateNameVisitor, Object.assign({
|
|
privateNamesMap,
|
|
classRef: ref,
|
|
file: state
|
|
}, handler, {
|
|
noDocumentAll,
|
|
noUninitializedPrivateFieldAccess,
|
|
innerBinding
|
|
}));
|
|
body.traverse(privateInVisitor, {
|
|
privateNamesMap,
|
|
classRef: ref,
|
|
file: state,
|
|
privateFieldsAsProperties,
|
|
innerBinding
|
|
});
|
|
}
|
|
function buildPrivateFieldInitLoose(ref, prop, privateNamesMap) {
|
|
const {
|
|
id
|
|
} = privateNamesMap.get(prop.node.key.id.name);
|
|
const value = prop.node.value || prop.scope.buildUndefinedNode();
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
Object.defineProperty(${ref}, ${_core.types.cloneNode(id)}, {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
writable: true,
|
|
value: ${value}
|
|
});
|
|
`, prop);
|
|
}
|
|
function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap, state) {
|
|
const {
|
|
id
|
|
} = privateNamesMap.get(prop.node.key.id.name);
|
|
const value = prop.node.value || prop.scope.buildUndefinedNode();
|
|
{
|
|
if (!state.availableHelper("classPrivateFieldInitSpec")) {
|
|
return inheritPropComments(_core.template.statement.ast`${_core.types.cloneNode(id)}.set(${ref}, {
|
|
// configurable is always false for private elements
|
|
// enumerable is always false for private elements
|
|
writable: true,
|
|
value: ${value},
|
|
})`, prop);
|
|
}
|
|
}
|
|
const helper = state.addHelper("classPrivateFieldInitSpec");
|
|
return inheritLoc(inheritPropComments(_core.types.expressionStatement(_core.types.callExpression(helper, [_core.types.thisExpression(), inheritLoc(_core.types.cloneNode(id), prop.node.key), newHelpers(state) ? value : _core.template.expression.ast`{ writable: true, value: ${value} }`])), prop), prop.node);
|
|
}
|
|
function buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const value = noUninitializedPrivateFieldAccess ? prop.node.value : _core.template.expression.ast`{
|
|
_: ${prop.node.value || _core.types.buildUndefinedNode()}
|
|
}`;
|
|
return inheritPropComments(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.cloneNode(privateName.id), value)]), prop);
|
|
}
|
|
{
|
|
var buildPrivateStaticFieldInitSpecOld = function (prop, privateNamesMap) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
id,
|
|
getId,
|
|
setId,
|
|
initAdded
|
|
} = privateName;
|
|
const isGetterOrSetter = getId || setId;
|
|
if (!prop.isProperty() && (initAdded || !isGetterOrSetter)) return;
|
|
if (isGetterOrSetter) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
initAdded: true
|
|
}));
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
var ${_core.types.cloneNode(id)} = {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
// writable is false by default
|
|
get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
|
|
set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
|
|
}
|
|
`, prop);
|
|
}
|
|
const value = prop.node.value || prop.scope.buildUndefinedNode();
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
var ${_core.types.cloneNode(id)} = {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
writable: true,
|
|
value: ${value}
|
|
};
|
|
`, prop);
|
|
};
|
|
}
|
|
function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
methodId,
|
|
id,
|
|
getId,
|
|
setId,
|
|
initAdded
|
|
} = privateName;
|
|
if (initAdded) return;
|
|
if (methodId) {
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
Object.defineProperty(${ref}, ${id}, {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
// writable is false by default
|
|
value: ${methodId.name}
|
|
});
|
|
`, prop);
|
|
}
|
|
const isGetterOrSetter = getId || setId;
|
|
if (isGetterOrSetter) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
initAdded: true
|
|
}));
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
Object.defineProperty(${ref}, ${id}, {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
// writable is false by default
|
|
get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
|
|
set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
|
|
});
|
|
`, prop);
|
|
}
|
|
}
|
|
function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap, state) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
if (privateName.initAdded) return;
|
|
if (!newHelpers(state)) {
|
|
const isGetterOrSetter = privateName.getId || privateName.setId;
|
|
if (isGetterOrSetter) {
|
|
return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state);
|
|
}
|
|
}
|
|
return buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state);
|
|
}
|
|
function buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
id,
|
|
getId,
|
|
setId
|
|
} = privateName;
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
initAdded: true
|
|
}));
|
|
{
|
|
if (!state.availableHelper("classPrivateFieldInitSpec")) {
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
${id}.set(${ref}, {
|
|
get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
|
|
set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
|
|
});
|
|
`, prop);
|
|
}
|
|
}
|
|
const helper = state.addHelper("classPrivateFieldInitSpec");
|
|
return inheritLoc(inheritPropComments(_core.template.statement.ast`${helper}(
|
|
${_core.types.thisExpression()},
|
|
${_core.types.cloneNode(id)},
|
|
{
|
|
get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
|
|
set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
|
|
},
|
|
)`, prop), prop.node);
|
|
}
|
|
function buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
id
|
|
} = privateName;
|
|
{
|
|
if (!state.availableHelper("classPrivateMethodInitSpec")) {
|
|
return inheritPropComments(_core.template.statement.ast`${id}.add(${ref})`, prop);
|
|
}
|
|
}
|
|
const helper = state.addHelper("classPrivateMethodInitSpec");
|
|
return inheritPropComments(_core.template.statement.ast`${helper}(
|
|
${_core.types.thisExpression()},
|
|
${_core.types.cloneNode(id)}
|
|
)`, prop);
|
|
}
|
|
function buildPublicFieldInitLoose(ref, prop) {
|
|
const {
|
|
key,
|
|
computed
|
|
} = prop.node;
|
|
const value = prop.node.value || prop.scope.buildUndefinedNode();
|
|
return inheritPropComments(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.memberExpression(ref, key, computed || _core.types.isLiteral(key)), value)), prop);
|
|
}
|
|
function buildPublicFieldInitSpec(ref, prop, state) {
|
|
const {
|
|
key,
|
|
computed
|
|
} = prop.node;
|
|
const value = prop.node.value || prop.scope.buildUndefinedNode();
|
|
return inheritPropComments(_core.types.expressionStatement(_core.types.callExpression(state.addHelper("defineProperty"), [ref, computed || _core.types.isLiteral(key) ? key : _core.types.stringLiteral(key.name), value])), prop);
|
|
}
|
|
function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
id,
|
|
methodId,
|
|
getId,
|
|
setId,
|
|
initAdded
|
|
} = privateName;
|
|
if (initAdded) return;
|
|
const isGetterOrSetter = getId || setId;
|
|
if (isGetterOrSetter) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
initAdded: true
|
|
}));
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
Object.defineProperty(${ref}, ${id}, {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
// writable is false by default
|
|
get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
|
|
set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
|
|
})
|
|
`, prop);
|
|
}
|
|
return inheritPropComments(_core.template.statement.ast`
|
|
Object.defineProperty(${ref}, ${id}, {
|
|
// configurable is false by default
|
|
// enumerable is false by default
|
|
// writable is false by default
|
|
value: ${methodId.name}
|
|
});
|
|
`, prop);
|
|
}
|
|
function buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties = false) {
|
|
const privateName = privateNamesMap.get(prop.node.key.id.name);
|
|
const {
|
|
id,
|
|
methodId,
|
|
getId,
|
|
setId,
|
|
getterDeclared,
|
|
setterDeclared,
|
|
static: isStatic
|
|
} = privateName;
|
|
const {
|
|
params,
|
|
body,
|
|
generator,
|
|
async
|
|
} = prop.node;
|
|
const isGetter = getId && params.length === 0;
|
|
const isSetter = setId && params.length > 0;
|
|
if (isGetter && getterDeclared || isSetter && setterDeclared) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
initAdded: true
|
|
}));
|
|
return null;
|
|
}
|
|
if (newHelpers(file) && (isGetter || isSetter) && !privateFieldsAsSymbolsOrProperties) {
|
|
const scope = prop.get("body").scope;
|
|
const thisArg = scope.generateUidIdentifier("this");
|
|
const state = {
|
|
thisRef: thisArg,
|
|
argumentsPath: []
|
|
};
|
|
prop.traverse(thisContextVisitor, state);
|
|
if (state.argumentsPath.length) {
|
|
const argumentsId = scope.generateUidIdentifier("arguments");
|
|
scope.push({
|
|
id: argumentsId,
|
|
init: _core.template.expression.ast`[].slice.call(arguments, 1)`
|
|
});
|
|
for (const path of state.argumentsPath) {
|
|
path.replaceWith(_core.types.cloneNode(argumentsId));
|
|
}
|
|
}
|
|
params.unshift(_core.types.cloneNode(thisArg));
|
|
}
|
|
let declId = methodId;
|
|
if (isGetter) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
getterDeclared: true,
|
|
initAdded: true
|
|
}));
|
|
declId = getId;
|
|
} else if (isSetter) {
|
|
privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
|
|
setterDeclared: true,
|
|
initAdded: true
|
|
}));
|
|
declId = setId;
|
|
} else if (isStatic && !privateFieldsAsSymbolsOrProperties) {
|
|
declId = id;
|
|
}
|
|
return inheritPropComments(_core.types.functionDeclaration(_core.types.cloneNode(declId), params, body, generator, async), prop);
|
|
}
|
|
const thisContextVisitor = _traverse.visitors.environmentVisitor({
|
|
Identifier(path, state) {
|
|
if (state.argumentsPath && path.node.name === "arguments") {
|
|
state.argumentsPath.push(path);
|
|
}
|
|
},
|
|
UnaryExpression(path) {
|
|
const {
|
|
node
|
|
} = path;
|
|
if (node.operator === "delete") {
|
|
const argument = (0, _helperSkipTransparentExpressionWrappers.skipTransparentExprWrapperNodes)(node.argument);
|
|
if (_core.types.isThisExpression(argument)) {
|
|
path.replaceWith(_core.types.booleanLiteral(true));
|
|
}
|
|
}
|
|
},
|
|
ThisExpression(path, state) {
|
|
state.needsClassRef = true;
|
|
path.replaceWith(_core.types.cloneNode(state.thisRef));
|
|
},
|
|
MetaProperty(path) {
|
|
const {
|
|
node,
|
|
scope
|
|
} = path;
|
|
if (node.meta.name === "new" && node.property.name === "target") {
|
|
path.replaceWith(scope.buildUndefinedNode());
|
|
}
|
|
}
|
|
});
|
|
const innerReferencesVisitor = {
|
|
ReferencedIdentifier(path, state) {
|
|
if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) {
|
|
state.needsClassRef = true;
|
|
path.node.name = state.thisRef.name;
|
|
}
|
|
}
|
|
};
|
|
function replaceThisContext(path, ref, innerBindingRef) {
|
|
var _state$thisRef;
|
|
const state = {
|
|
thisRef: ref,
|
|
needsClassRef: false,
|
|
innerBinding: innerBindingRef
|
|
};
|
|
if (!path.isMethod()) {
|
|
path.traverse(thisContextVisitor, state);
|
|
}
|
|
if (innerBindingRef != null && (_state$thisRef = state.thisRef) != null && _state$thisRef.name && state.thisRef.name !== innerBindingRef.name) {
|
|
path.traverse(innerReferencesVisitor, state);
|
|
}
|
|
return state.needsClassRef;
|
|
}
|
|
function isNameOrLength({
|
|
key,
|
|
computed
|
|
}) {
|
|
if (key.type === "Identifier") {
|
|
return !computed && (key.name === "name" || key.name === "length");
|
|
}
|
|
if (key.type === "StringLiteral") {
|
|
return key.value === "name" || key.value === "length";
|
|
}
|
|
return false;
|
|
}
|
|
function inheritPropComments(node, prop) {
|
|
_core.types.inheritLeadingComments(node, prop.node);
|
|
_core.types.inheritInnerComments(node, prop.node);
|
|
return node;
|
|
}
|
|
function inheritLoc(node, original) {
|
|
node.start = original.start;
|
|
node.end = original.end;
|
|
node.loc = original.loc;
|
|
return node;
|
|
}
|
|
function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsSymbolsOrProperties, noUninitializedPrivateFieldAccess, constantSuper, innerBindingRef) {
|
|
let classRefFlags = 0;
|
|
let injectSuperRef;
|
|
const staticNodes = [];
|
|
const instanceNodes = [];
|
|
let lastInstanceNodeReturnsThis = false;
|
|
const pureStaticNodes = [];
|
|
let classBindingNode = null;
|
|
const getSuperRef = _core.types.isIdentifier(superRef) ? () => superRef : () => {
|
|
injectSuperRef != null ? injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef);
|
|
return injectSuperRef;
|
|
};
|
|
const classRefForInnerBinding = ref != null ? ref : props[0].scope.generateUidIdentifier((innerBindingRef == null ? void 0 : innerBindingRef.name) || "Class");
|
|
ref != null ? ref : ref = _core.types.cloneNode(innerBindingRef);
|
|
for (const prop of props) {
|
|
if (prop.isClassProperty()) {
|
|
ts.assertFieldTransformed(prop);
|
|
}
|
|
const isStatic = !(_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node)) && prop.node.static;
|
|
const isInstance = !isStatic;
|
|
const isPrivate = prop.isPrivate();
|
|
const isPublic = !isPrivate;
|
|
const isField = prop.isProperty();
|
|
const isMethod = !isField;
|
|
const isStaticBlock = prop.isStaticBlock == null ? void 0 : prop.isStaticBlock();
|
|
if (isStatic) classRefFlags |= 1;
|
|
if (isStatic || isMethod && isPrivate || isStaticBlock) {
|
|
new _helperReplaceSupers.default({
|
|
methodPath: prop,
|
|
constantSuper,
|
|
file: file,
|
|
refToPreserve: innerBindingRef,
|
|
getSuperRef,
|
|
getObjectRef() {
|
|
classRefFlags |= 2;
|
|
if (isStatic || isStaticBlock) {
|
|
return classRefForInnerBinding;
|
|
} else {
|
|
return _core.types.memberExpression(classRefForInnerBinding, _core.types.identifier("prototype"));
|
|
}
|
|
}
|
|
}).replace();
|
|
const replaced = replaceThisContext(prop, classRefForInnerBinding, innerBindingRef);
|
|
if (replaced) {
|
|
classRefFlags |= 2;
|
|
}
|
|
}
|
|
lastInstanceNodeReturnsThis = false;
|
|
switch (true) {
|
|
case isStaticBlock:
|
|
{
|
|
const blockBody = prop.node.body;
|
|
if (blockBody.length === 1 && _core.types.isExpressionStatement(blockBody[0])) {
|
|
staticNodes.push(inheritPropComments(blockBody[0], prop));
|
|
} else {
|
|
staticNodes.push(_core.types.inheritsComments(_core.template.statement.ast`(() => { ${blockBody} })()`, prop.node));
|
|
}
|
|
break;
|
|
}
|
|
case isStatic && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
|
|
staticNodes.push(buildPrivateFieldInitLoose(_core.types.cloneNode(ref), prop, privateNamesMap));
|
|
break;
|
|
case isStatic && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
|
|
if (!newHelpers(file)) {
|
|
staticNodes.push(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
|
|
} else {
|
|
staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess));
|
|
}
|
|
break;
|
|
case isStatic && isPublic && isField && setPublicClassFields:
|
|
if (!isNameOrLength(prop.node)) {
|
|
staticNodes.push(buildPublicFieldInitLoose(_core.types.cloneNode(ref), prop));
|
|
break;
|
|
}
|
|
case isStatic && isPublic && isField && !setPublicClassFields:
|
|
staticNodes.push(buildPublicFieldInitSpec(_core.types.cloneNode(ref), prop, file));
|
|
break;
|
|
case isInstance && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
|
|
instanceNodes.push(buildPrivateFieldInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
|
|
break;
|
|
case isInstance && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
|
|
instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file));
|
|
break;
|
|
case isInstance && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
|
|
instanceNodes.unshift(buildPrivateMethodInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
|
|
pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
|
|
break;
|
|
case isInstance && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
|
|
instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file));
|
|
pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
|
|
break;
|
|
case isStatic && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
|
|
if (!newHelpers(file)) {
|
|
staticNodes.unshift(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
|
|
}
|
|
pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
|
|
break;
|
|
case isStatic && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
|
|
staticNodes.unshift(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref), prop, file, privateNamesMap));
|
|
pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
|
|
break;
|
|
case isInstance && isPublic && isField && setPublicClassFields:
|
|
instanceNodes.push(buildPublicFieldInitLoose(_core.types.thisExpression(), prop));
|
|
break;
|
|
case isInstance && isPublic && isField && !setPublicClassFields:
|
|
lastInstanceNodeReturnsThis = true;
|
|
instanceNodes.push(buildPublicFieldInitSpec(_core.types.thisExpression(), prop, file));
|
|
break;
|
|
default:
|
|
throw new Error("Unreachable.");
|
|
}
|
|
}
|
|
if (classRefFlags & 2 && innerBindingRef != null) {
|
|
classBindingNode = _core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(classRefForInnerBinding), _core.types.cloneNode(innerBindingRef)));
|
|
}
|
|
return {
|
|
staticNodes: staticNodes.filter(Boolean),
|
|
instanceNodes: instanceNodes.filter(Boolean),
|
|
lastInstanceNodeReturnsThis,
|
|
pureStaticNodes: pureStaticNodes.filter(Boolean),
|
|
classBindingNode,
|
|
wrapClass(path) {
|
|
for (const prop of props) {
|
|
prop.node.leadingComments = null;
|
|
prop.remove();
|
|
}
|
|
if (injectSuperRef) {
|
|
path.scope.push({
|
|
id: _core.types.cloneNode(injectSuperRef)
|
|
});
|
|
path.set("superClass", _core.types.assignmentExpression("=", injectSuperRef, path.node.superClass));
|
|
}
|
|
if (classRefFlags !== 0) {
|
|
if (path.isClassExpression()) {
|
|
path.scope.push({
|
|
id: ref
|
|
});
|
|
path.replaceWith(_core.types.assignmentExpression("=", _core.types.cloneNode(ref), path.node));
|
|
} else {
|
|
if (innerBindingRef == null) {
|
|
path.node.id = ref;
|
|
}
|
|
if (classBindingNode != null) {
|
|
path.scope.push({
|
|
id: classRefForInnerBinding
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
};
|
|
}
|
|
|
|
//# sourceMappingURL=fields.js.map
|