Befor generating
This commit is contained in:
marys committed
1 parent
3383f4bf4a
commit
1aa1b5f625
6756 files changed
+649946
-1
No files matched your search
Generated
Vendored
+124
@@ -0,0 +1,124 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.buildDecoratedClass = buildDecoratedClass;
|
||||
var _core = require("@babel/core");
|
||||
var _helperReplaceSupers = require("@babel/helper-replace-supers");
|
||||
function prop(key, value) {
|
||||
if (!value) return null;
|
||||
return _core.types.objectProperty(_core.types.identifier(key), value);
|
||||
}
|
||||
function method(key, body) {
|
||||
return _core.types.objectMethod("method", _core.types.identifier(key), [], _core.types.blockStatement(body));
|
||||
}
|
||||
function takeDecorators(node) {
|
||||
let result;
|
||||
if (node.decorators && node.decorators.length > 0) {
|
||||
result = _core.types.arrayExpression(node.decorators.map(decorator => decorator.expression));
|
||||
}
|
||||
node.decorators = undefined;
|
||||
return result;
|
||||
}
|
||||
function getKey(node) {
|
||||
if (node.computed) {
|
||||
return node.key;
|
||||
} else if (_core.types.isIdentifier(node.key)) {
|
||||
return _core.types.stringLiteral(node.key.name);
|
||||
} else {
|
||||
return _core.types.stringLiteral(String(node.key.value));
|
||||
}
|
||||
}
|
||||
function extractElementDescriptor(file, classRef, superRef, path) {
|
||||
const isMethod = path.isClassMethod();
|
||||
if (path.isPrivate()) {
|
||||
throw path.buildCodeFrameError(`Private ${isMethod ? "methods" : "fields"} in decorated classes are not supported yet.`);
|
||||
}
|
||||
if (path.node.type === "ClassAccessorProperty") {
|
||||
throw path.buildCodeFrameError(`Accessor properties are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
|
||||
}
|
||||
if (path.node.type === "StaticBlock") {
|
||||
throw path.buildCodeFrameError(`Static blocks are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
|
||||
}
|
||||
const {
|
||||
node,
|
||||
scope
|
||||
} = path;
|
||||
if (!path.isTSDeclareMethod()) {
|
||||
new _helperReplaceSupers.default({
|
||||
methodPath: path,
|
||||
objectRef: classRef,
|
||||
superRef,
|
||||
file,
|
||||
refToPreserve: classRef
|
||||
}).replace();
|
||||
}
|
||||
const properties = [prop("kind", _core.types.stringLiteral(_core.types.isClassMethod(node) ? node.kind : "field")), prop("decorators", takeDecorators(node)), prop("static", node.static && _core.types.booleanLiteral(true)), prop("key", getKey(node))].filter(Boolean);
|
||||
if (isMethod) {
|
||||
var _path$ensureFunctionN;
|
||||
(_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
|
||||
path.ensureFunctionName(false);
|
||||
properties.push(prop("value", _core.types.toExpression(path.node)));
|
||||
} else if (_core.types.isClassProperty(node) && node.value) {
|
||||
properties.push(method("value", _core.template.statements.ast`return ${node.value}`));
|
||||
} else {
|
||||
properties.push(prop("value", scope.buildUndefinedNode()));
|
||||
}
|
||||
path.remove();
|
||||
return _core.types.objectExpression(properties);
|
||||
}
|
||||
function addDecorateHelper(file) {
|
||||
return file.addHelper("decorate");
|
||||
}
|
||||
function buildDecoratedClass(ref, path, elements, file) {
|
||||
const {
|
||||
node,
|
||||
scope
|
||||
} = path;
|
||||
const initializeId = scope.generateUidIdentifier("initialize");
|
||||
const isDeclaration = node.id && path.isDeclaration();
|
||||
const isStrict = path.isInStrictMode();
|
||||
const {
|
||||
superClass
|
||||
} = node;
|
||||
node.type = "ClassDeclaration";
|
||||
if (!node.id) node.id = _core.types.cloneNode(ref);
|
||||
let superId;
|
||||
if (superClass) {
|
||||
superId = scope.generateUidIdentifierBasedOnNode(node.superClass, "super");
|
||||
node.superClass = superId;
|
||||
}
|
||||
const classDecorators = takeDecorators(node);
|
||||
const definitions = _core.types.arrayExpression(elements.filter(element => !element.node.abstract && element.node.type !== "TSIndexSignature").map(path => extractElementDescriptor(file, node.id, superId, path)));
|
||||
const wrapperCall = _core.template.expression.ast`
|
||||
${addDecorateHelper(file)}(
|
||||
${classDecorators || _core.types.nullLiteral()},
|
||||
function (${initializeId}, ${superClass ? _core.types.cloneNode(superId) : null}) {
|
||||
${node}
|
||||
return { F: ${_core.types.cloneNode(node.id)}, d: ${definitions} };
|
||||
},
|
||||
${superClass}
|
||||
)
|
||||
`;
|
||||
if (!isStrict) {
|
||||
wrapperCall.arguments[1].body.directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
|
||||
}
|
||||
let replacement = wrapperCall;
|
||||
let classPathDesc = "arguments.1.body.body.0";
|
||||
if (isDeclaration) {
|
||||
replacement = _core.template.statement.ast`let ${ref} = ${wrapperCall}`;
|
||||
classPathDesc = "declarations.0.init." + classPathDesc;
|
||||
}
|
||||
return {
|
||||
instanceNodes: [_core.template.statement.ast`
|
||||
${_core.types.cloneNode(initializeId)}(this)
|
||||
`],
|
||||
wrapClass(path) {
|
||||
path.replaceWith(replacement);
|
||||
return path.get(classPathDesc);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=decorators-2018-09.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_core","require","_helperReplaceSupers","prop","key","value","t","objectProperty","identifier","method","body","objectMethod","blockStatement","takeDecorators","node","result","decorators","length","arrayExpression","map","decorator","expression","undefined","getKey","computed","isIdentifier","stringLiteral","name","String","extractElementDescriptor","file","classRef","superRef","path","isMethod","isClassMethod","isPrivate","buildCodeFrameError","type","scope","isTSDeclareMethod","ReplaceSupers","methodPath","objectRef","refToPreserve","replace","properties","kind","static","booleanLiteral","filter","Boolean","_path$ensureFunctionN","ensureFunctionName","NodePath","prototype","push","toExpression","isClassProperty","template","statements","ast","buildUndefinedNode","remove","objectExpression","addDecorateHelper","addHelper","buildDecoratedClass","ref","elements","initializeId","generateUidIdentifier","isDeclaration","id","isStrict","isInStrictMode","superClass","cloneNode","superId","generateUidIdentifierBasedOnNode","classDecorators","definitions","element","abstract","wrapperCall","nullLiteral","arguments","directives","directive","directiveLiteral","replacement","classPathDesc","statement","instanceNodes","wrapClass","replaceWith","get"],"sources":["../src/decorators-2018-09.ts"],"sourcesContent":["// TODO(Babel 8): Remove this file\nif (process.env.BABEL_8_BREAKING && process.env.IS_PUBLISH) {\n throw new Error(\n \"Internal Babel error: This file should only be loaded in Babel 7\",\n );\n}\n\nimport { types as t, template } from \"@babel/core\";\nimport type { File, NodePath } from \"@babel/core\";\nimport ReplaceSupers from \"@babel/helper-replace-supers\";\n\ntype Decoratable = Extract<t.Node, { decorators?: t.Decorator[] | null }>;\n\nfunction prop(key: string, value?: t.Expression) {\n if (!value) return null;\n return t.objectProperty(t.identifier(key), value);\n}\n\nfunction method(key: string, body: t.Statement[]) {\n return t.objectMethod(\n \"method\",\n t.identifier(key),\n [],\n t.blockStatement(body),\n );\n}\n\nfunction takeDecorators(node: Decoratable) {\n let result: t.ArrayExpression | undefined;\n if (node.decorators && node.decorators.length > 0) {\n result = t.arrayExpression(\n node.decorators.map(decorator => decorator.expression),\n );\n }\n node.decorators = undefined;\n return result;\n}\n\ntype AcceptedElement = Exclude<ClassElement, t.TSIndexSignature>;\ntype SupportedElement = Exclude<\n AcceptedElement,\n | t.ClassPrivateMethod\n | t.ClassPrivateProperty\n | t.ClassAccessorProperty\n | t.StaticBlock\n>;\n\nfunction getKey(node: SupportedElement) {\n if (node.computed) {\n return node.key;\n } else if (t.isIdentifier(node.key)) {\n return t.stringLiteral(node.key.name);\n } else {\n return t.stringLiteral(\n String(\n // A non-identifier non-computed key\n (node.key as t.StringLiteral | t.NumericLiteral | t.BigIntLiteral)\n .value,\n ),\n );\n }\n}\n\nfunction extractElementDescriptor(\n file: File,\n classRef: t.Identifier,\n superRef: t.Identifier,\n path: NodePath<AcceptedElement>,\n) {\n const isMethod = path.isClassMethod();\n if (path.isPrivate()) {\n throw path.buildCodeFrameError(\n `Private ${\n isMethod ? \"methods\" : \"fields\"\n } in decorated classes are not supported yet.`,\n );\n }\n if (path.node.type === \"ClassAccessorProperty\") {\n throw path.buildCodeFrameError(\n `Accessor properties are not supported in 2018-09 decorator transform, please specify { \"version\": \"2021-12\" } instead.`,\n );\n }\n if (path.node.type === \"StaticBlock\") {\n throw path.buildCodeFrameError(\n `Static blocks are not supported in 2018-09 decorator transform, please specify { \"version\": \"2021-12\" } instead.`,\n );\n }\n\n const { node, scope } = path as NodePath<SupportedElement>;\n\n if (!path.isTSDeclareMethod()) {\n new ReplaceSupers({\n methodPath: path as NodePath<\n Exclude<SupportedElement, t.TSDeclareMethod>\n >,\n objectRef: classRef,\n superRef,\n file,\n refToPreserve: classRef,\n }).replace();\n }\n\n const properties: t.ObjectExpression[\"properties\"] = [\n prop(\"kind\", t.stringLiteral(t.isClassMethod(node) ? node.kind : \"field\")),\n prop(\"decorators\", takeDecorators(node as Decoratable)),\n prop(\"static\", node.static && t.booleanLiteral(true)),\n prop(\"key\", getKey(node)),\n ].filter(Boolean);\n\n if (isMethod) {\n if (!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE) {\n // polyfill when being run by an older Babel version\n path.ensureFunctionName ??=\n // eslint-disable-next-line no-restricted-globals\n require(\"@babel/traverse\").NodePath.prototype.ensureFunctionName;\n }\n // @ts-expect-error path is a ClassMethod, that technically\n // is not supported as it does noLine truncated
|
||||
Generated
Vendored
+1312
File diff suppressed because it is too large.
Load diff
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_core","require","_helperReplaceSupers","_helperSkipTransparentExpressionWrappers","_fields","_misc","hasOwnDecorators","node","_node$decorators","decorators","length","hasDecorators","body","some","incrementId","id","idx","unshift","current","createPrivateUidGeneratorForClass","classPath","currentPrivateId","privateNames","Set","t","traverseFast","isPrivateName","add","name","reifiedId","String","fromCharCode","has","privateName","identifier","createLazyPrivateUidGeneratorForClass","generator","replaceClassWithVar","path","className","scope","type","varId","generateUidIdentifierBasedOnNode","classId","rename","get","replaceWith","cloneNode","generateLetUidIdentifier","parent","newClassExpr","classExpression","superClass","newPath","sequenceExpression","generateClassProperty","key","value","isStatic","classPrivateProperty","undefined","classProperty","assignIdForAnonymousClass","generateUidIdentifier","addProxyAccessorsFor","element","getterKey","setterKey","targetKey","isComputed","version","thisArg","thisExpression","getterBody","blockStatement","returnStatement","memberExpression","setterBody","expressionStatement","assignmentExpression","getter","setter","classPrivateMethod","classMethod","insertAfter","extractProxyAccessorsFor","template","expression","ast","getComputedKeyLastElement","skipTransparentExprWrappers","isSequenceExpression","expressions","getComputedKeyMemoiser","isConstantExpression","isIdentifier","hasUid","isAssignmentExpression","left","Error","toString","prependExpressionsToComputedKey","fieldPath","push","maybeSequenceExpression","appendExpressionsToComputedKey","completion","scopeParent","maybeAssignment","memoiseComputedKey","generateUid","expressionSequence","completionParent","parentPath","pushContainer","prependExpressionsToFieldInitializer","initializer","unaryExpression","prependExpressionsToStaticBlock","blockPath","unshiftContainer","prependExpressionsToConstructor","constructorPath","isProtoInitCallExpression","protoInitCall","isCallExpression","callee","optimizeSuperCallAndExpressions","protoInitLocal","mergedSuperCall","callExpression","splice","isThisExpression","insertExpressionsAfterSuperCallAndOptimize","traverse","CallExpression","exit","isSuper","newNodes","map","expr","isCompletionRecord","skip","ClassMethod","kind","createConstructorFromExpressions","isDerivedClass","super","spreadElement","restElement","createStaticBlockFromExpressions","staticBlock","FIELD","ACCESSOR","METHOD","GETTER","SETTER","STATIC_OLD_VERSION","STATIC","DECORATORS_HAVE_THIS","getElementKind","toSortedDecoratorInfo","info","filter","el","generateDecorationList","decoratorsThis","decsCount","haveOneThis","Boolean","decs","i","numericLiteral","haveThis","generateDecorationExprs","decorationInfo","arrayExpression","flag","decoratorsHaveThis","decoratorsArray","privateMethods","extractElementLocalAssignments","localIds","locals","Array","isArray","addCallAccessorsFor","getId","setId","movePrivateAccessor","methodLocalVar","params","block","isClassDecoratableElementPath","staticBlockToIIFE","arrowFunctionExpression","staticBlockToFunctionClosure","functionExpression","fieldInitializerToClosure","exprs","createFunctionExpressionFromPrivateMethod","isGenerator","async","isAsync","createSetFunctionNameCall","state","addHelper","createToPropertyKeyCall","propertyKey","createPrivateBrandCheckClosure","brandName","binaryExpression","usesPrivateField","_unused","convertToComputedKey","computed","stringLiteral","hasInstancePrivateAccess","containsInstancePrivateAccess","privateNameVisitor","privateNameVisitorFactory","PrivateName","privateNamesMap","stop","Map","set","checkPrivateMethodUpdateError","decoratedPrivateMethods","parentParentPath","buildCodeFrameError","transformClass","constantSuper","ignoreFunctionLength","propertyVisitor","_path$node$id","classDecorators","hasElementDecorators","hasComputedKeysSideEffects","elemDecsUseFnContext","generateClassPrivateUid","classAssignments","memoiseExpression","hint","assignments","localEvaluatedId","staticInitLocal","classIdName","setClassName","usesFunctionContextOrYieldAwait","decorator","isYieldExpression","isAwaitExpression","isMetaProperty","meta","_unused2","instancePrivateNames","elementNode","static","isDecorated","ClassProperty","ClassPrivateProperty","ClassAccessorProperty","newId","newField","keyPath","elementDecoratorInfo","classInitLocal","classIdLocal","decoratorReceiverId","handleDecorators","hasSideEffects","usesFnContext","object","isMemberExpression","willExtractSomeElemDecs","needsDeclarationForClassBinding","classDecorationsFlag","classDecorations","classDecorationsId","computedKeyAssignments","isClassDeclaration","classDecsUsePrivateName","isClassProperty","lastInstancePrivateName","needsInstancePrivateBrandCheck","fieldInitializerExpressions","staticFieldInitializerExpressions","isStaticBlock","isPrivate","isClassPrivateProperty","isClassMethod","nameExpr","newFieldInitId","newValue","initId","valuePath","args"Line truncated
|
||||
Generated
Vendored
+137
@@ -0,0 +1,137 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.FEATURES = void 0;
|
||||
exports.enableFeature = enableFeature;
|
||||
exports.isLoose = isLoose;
|
||||
exports.shouldTransform = shouldTransform;
|
||||
var _decorators = require("./decorators.js");
|
||||
const FEATURES = exports.FEATURES = Object.freeze({
|
||||
fields: 1 << 1,
|
||||
privateMethods: 1 << 2,
|
||||
decorators: 1 << 3,
|
||||
privateIn: 1 << 4,
|
||||
staticBlocks: 1 << 5
|
||||
});
|
||||
const featuresSameLoose = new Map([[FEATURES.fields, "@babel/plugin-transform-class-properties"], [FEATURES.privateMethods, "@babel/plugin-transform-private-methods"], [FEATURES.privateIn, "@babel/plugin-transform-private-property-in-object"]]);
|
||||
const featuresKey = "@babel/plugin-class-features/featuresKey";
|
||||
const looseKey = "@babel/plugin-class-features/looseKey";
|
||||
var looseLowPriorityKey = "@babel/plugin-class-features/looseLowPriorityKey/#__internal__@babel/preset-env__please-overwrite-loose-instead-of-throwing";
|
||||
var canIgnoreLoose = function (file, feature) {
|
||||
return !!(file.get(looseLowPriorityKey) & feature);
|
||||
};
|
||||
function enableFeature(file, feature, loose) {
|
||||
if (!hasFeature(file, feature) || canIgnoreLoose(file, feature)) {
|
||||
file.set(featuresKey, file.get(featuresKey) | feature);
|
||||
if (loose === "#__internal__@babel/preset-env__prefer-true-but-false-is-ok-if-it-prevents-an-error") {
|
||||
setLoose(file, feature, true);
|
||||
file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
|
||||
} else if (loose === "#__internal__@babel/preset-env__prefer-false-but-true-is-ok-if-it-prevents-an-error") {
|
||||
setLoose(file, feature, false);
|
||||
file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
|
||||
} else {
|
||||
setLoose(file, feature, loose);
|
||||
}
|
||||
}
|
||||
let resolvedLoose;
|
||||
for (const [mask, name] of featuresSameLoose) {
|
||||
if (!hasFeature(file, mask)) continue;
|
||||
if (canIgnoreLoose(file, mask)) continue;
|
||||
const loose = isLoose(file, mask);
|
||||
if (resolvedLoose === !loose) {
|
||||
throw new Error("'loose' mode configuration must be the same for @babel/plugin-transform-class-properties, " + "@babel/plugin-transform-private-methods and " + "@babel/plugin-transform-private-property-in-object (when they are enabled)." + "\n\n" + getBabelShowConfigForHint(file));
|
||||
} else {
|
||||
resolvedLoose = loose;
|
||||
var higherPriorityPluginName = name;
|
||||
}
|
||||
}
|
||||
if (resolvedLoose !== undefined) {
|
||||
for (const [mask, name] of featuresSameLoose) {
|
||||
if (hasFeature(file, mask) && isLoose(file, mask) !== resolvedLoose) {
|
||||
setLoose(file, mask, resolvedLoose);
|
||||
console.warn(`Though the "loose" option was set to "${!resolvedLoose}" in your @babel/preset-env ` + `config, it will not be used for ${name} since the "loose" mode option was set to ` + `"${resolvedLoose}" for ${higherPriorityPluginName}.\nThe "loose" option must be the ` + `same for @babel/plugin-transform-class-properties, @babel/plugin-transform-private-methods ` + `and @babel/plugin-transform-private-property-in-object (when they are enabled): you can ` + `silence this warning by explicitly adding\n` + `\t["${name}", { "loose": ${resolvedLoose} }]\n` + `to the "plugins" section of your Babel config.` + "\n\n" + getBabelShowConfigForHint(file));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function getBabelShowConfigForHint(file) {
|
||||
let {
|
||||
filename
|
||||
} = file.opts;
|
||||
if (!filename || filename === "unknown") {
|
||||
filename = "[name of the input file]";
|
||||
}
|
||||
return `\
|
||||
If you already set the same 'loose' mode for these plugins in your config, it's possible that they \
|
||||
are enabled multiple times with different options.
|
||||
You can re-run Babel with the BABEL_SHOW_CONFIG_FOR environment variable to show the loaded \
|
||||
configuration:
|
||||
\tnpx cross-env BABEL_SHOW_CONFIG_FOR=${filename} <your build command>
|
||||
See https://babeljs.io/docs/configuration#print-effective-configs for more info.`;
|
||||
}
|
||||
function hasFeature(file, feature) {
|
||||
return !!(file.get(featuresKey) & feature);
|
||||
}
|
||||
function isLoose(file, feature) {
|
||||
return !!(file.get(looseKey) & feature);
|
||||
}
|
||||
function setLoose(file, feature, loose) {
|
||||
if (loose) file.set(looseKey, file.get(looseKey) | feature);else file.set(looseKey, file.get(looseKey) & ~feature);
|
||||
file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) & ~feature);
|
||||
}
|
||||
function shouldTransform(path, file) {
|
||||
let decoratorPath = null;
|
||||
let publicFieldPath = null;
|
||||
let privateFieldPath = null;
|
||||
let privateMethodPath = null;
|
||||
let staticBlockPath = null;
|
||||
if ((0, _decorators.hasOwnDecorators)(path.node)) {
|
||||
decoratorPath = path.get("decorators.0");
|
||||
}
|
||||
for (const el of path.get("body.body")) {
|
||||
if (!decoratorPath && (0, _decorators.hasOwnDecorators)(el.node)) {
|
||||
decoratorPath = el.get("decorators.0");
|
||||
}
|
||||
if (!publicFieldPath && el.isClassProperty()) {
|
||||
publicFieldPath = el;
|
||||
}
|
||||
if (!privateFieldPath && el.isClassPrivateProperty()) {
|
||||
privateFieldPath = el;
|
||||
}
|
||||
if (!privateMethodPath && el.isClassPrivateMethod != null && el.isClassPrivateMethod()) {
|
||||
privateMethodPath = el;
|
||||
}
|
||||
if (!staticBlockPath && el.isStaticBlock != null && el.isStaticBlock()) {
|
||||
staticBlockPath = el;
|
||||
}
|
||||
}
|
||||
if (decoratorPath && privateFieldPath) {
|
||||
throw privateFieldPath.buildCodeFrameError("Private fields in decorated classes are not supported yet.");
|
||||
}
|
||||
if (decoratorPath && privateMethodPath) {
|
||||
throw privateMethodPath.buildCodeFrameError("Private methods in decorated classes are not supported yet.");
|
||||
}
|
||||
if (decoratorPath && !hasFeature(file, FEATURES.decorators)) {
|
||||
throw path.buildCodeFrameError("Decorators are not enabled." + "\nIf you are using " + '["@babel/plugin-proposal-decorators", { "version": "legacy" }], ' + 'make sure it comes *before* "@babel/plugin-transform-class-properties" ' + "and enable loose mode, like so:\n" + '\t["@babel/plugin-proposal-decorators", { "version": "legacy" }]\n' + '\t["@babel/plugin-transform-class-properties", { "loose": true }]');
|
||||
}
|
||||
if (privateMethodPath && !hasFeature(file, FEATURES.privateMethods)) {
|
||||
throw privateMethodPath.buildCodeFrameError("Class private methods are not enabled. " + "Please add `@babel/plugin-transform-private-methods` to your configuration.");
|
||||
}
|
||||
if ((publicFieldPath || privateFieldPath) && !hasFeature(file, FEATURES.fields) && !hasFeature(file, FEATURES.privateMethods)) {
|
||||
throw path.buildCodeFrameError("Class fields are not enabled. " + "Please add `@babel/plugin-transform-class-properties` to your configuration.");
|
||||
}
|
||||
if (staticBlockPath && !hasFeature(file, FEATURES.staticBlocks)) {
|
||||
throw path.buildCodeFrameError("Static class blocks are not enabled. " + "Please add `@babel/plugin-transform-class-static-block` to your configuration.");
|
||||
}
|
||||
if (decoratorPath || privateMethodPath || staticBlockPath) {
|
||||
return true;
|
||||
}
|
||||
if ((publicFieldPath || privateFieldPath) && hasFeature(file, FEATURES.fields)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=features.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_decorators","require","FEATURES","exports","Object","freeze","fields","privateMethods","decorators","privateIn","staticBlocks","featuresSameLoose","Map","featuresKey","looseKey","looseLowPriorityKey","canIgnoreLoose","file","feature","get","enableFeature","loose","hasFeature","set","setLoose","resolvedLoose","mask","name","isLoose","Error","getBabelShowConfigForHint","higherPriorityPluginName","undefined","console","warn","filename","opts","shouldTransform","path","decoratorPath","publicFieldPath","privateFieldPath","privateMethodPath","staticBlockPath","hasOwnDecorators","node","el","isClassProperty","isClassPrivateProperty","isClassPrivateMethod","isStaticBlock","buildCodeFrameError"],"sources":["../src/features.ts"],"sourcesContent":["import type { File, types as t } from \"@babel/core\";\nimport type { NodePath } from \"@babel/core\";\nimport { hasOwnDecorators } from \"./decorators.ts\";\n\nexport const FEATURES = Object.freeze({\n //classes: 1 << 0,\n fields: 1 << 1,\n privateMethods: 1 << 2,\n decorators: 1 << 3,\n privateIn: 1 << 4,\n staticBlocks: 1 << 5,\n});\n\nconst featuresSameLoose = new Map([\n [FEATURES.fields, \"@babel/plugin-transform-class-properties\"],\n [FEATURES.privateMethods, \"@babel/plugin-transform-private-methods\"],\n [FEATURES.privateIn, \"@babel/plugin-transform-private-property-in-object\"],\n]);\n\n// We can't use a symbol because this needs to always be the same, even if\n// this package isn't deduped by npm. e.g.\n// - node_modules/\n// - @babel/plugin-class-features\n// - @babel/plugin-proposal-decorators\n// - node_modules\n// - @babel-plugin-class-features\nconst featuresKey = \"@babel/plugin-class-features/featuresKey\";\nconst looseKey = \"@babel/plugin-class-features/looseKey\";\n\nif (!process.env.BABEL_8_BREAKING) {\n // See https://github.com/babel/babel/issues/11622.\n // Since preset-env sets loose for the fields and private methods plugins, it can\n // cause conflicts with the loose mode set by an explicit plugin in the config.\n // To solve this problem, we ignore preset-env's loose mode if another plugin\n // explicitly sets it\n // The code to handle this logic doesn't check that \"low priority loose\" is always\n // the same. However, it is only set by the preset and not directly by users:\n // unless someone _wants_ to break it, it shouldn't be a problem.\n // eslint-disable-next-line no-var\n var looseLowPriorityKey =\n \"@babel/plugin-class-features/looseLowPriorityKey/#__internal__@babel/preset-env__please-overwrite-loose-instead-of-throwing\";\n}\n\nif (!process.env.BABEL_8_BREAKING) {\n // eslint-disable-next-line no-var\n var canIgnoreLoose = function (file: File, feature: number) {\n return !!(file.get(looseLowPriorityKey) & feature);\n };\n}\n\nexport function enableFeature(file: File, feature: number, loose: boolean) {\n // We can't blindly enable the feature because, if it was already set,\n // \"loose\" can't be changed, so that\n // @babel/plugin-class-properties { loose: true }\n // @babel/plugin-class-properties { loose: false }\n // is transformed in loose mode.\n // We only enabled the feature if it was previously disabled.\n if (process.env.BABEL_8_BREAKING) {\n if (!hasFeature(file, feature)) {\n file.set(featuresKey, file.get(featuresKey) | feature);\n setLoose(file, feature, loose);\n }\n } else if (!hasFeature(file, feature) || canIgnoreLoose(file, feature)) {\n file.set(featuresKey, file.get(featuresKey) | feature);\n if (\n // @ts-expect-error comparing loose with internal private magic string\n loose ===\n \"#__internal__@babel/preset-env__prefer-true-but-false-is-ok-if-it-prevents-an-error\"\n ) {\n setLoose(file, feature, true);\n file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);\n } else if (\n // @ts-expect-error comparing loose with internal private magic string\n loose ===\n \"#__internal__@babel/preset-env__prefer-false-but-true-is-ok-if-it-prevents-an-error\"\n ) {\n setLoose(file, feature, false);\n file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);\n } else {\n setLoose(file, feature, loose);\n }\n }\n\n let resolvedLoose: boolean | undefined;\n for (const [mask, name] of featuresSameLoose) {\n if (!hasFeature(file, mask)) continue;\n if (!process.env.BABEL_8_BREAKING) {\n if (canIgnoreLoose(file, mask)) continue;\n }\n\n const loose = isLoose(file, mask);\n\n if (resolvedLoose === !loose) {\n throw new Error(\n \"'loose' mode configuration must be the same for @babel/plugin-transform-class-properties, \" +\n \"@babel/plugin-transform-private-methods and \" +\n \"@babel/plugin-transform-private-property-in-object (when they are enabled).\" +\n \"\\n\\n\" +\n getBabelShowConfigForHint(file),\n );\n } else {\n resolvedLoose = Line truncated
|
||||
Generated
Vendored
+1041
File diff suppressed because it is too large.
Load diff
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_core","require","_traverse","_helperReplaceSupers","_helperMemberExpressionToFunctions","_helperOptimiseCallExpression","_helperAnnotateAsPure","_helperSkipTransparentExpressionWrappers","ts","newHelpers","file","availableHelper","buildPrivateNamesMap","className","privateFieldsAsSymbolsOrProperties","props","privateNamesMap","Map","classBrandId","prop","isPrivate","name","node","key","id","update","get","isMethod","isProperty","isStatic","static","initAdded","scope","generateUidIdentifier","method","set","isClassPrivateMethod","kind","body","$","length","t","isReturnStatement","isCallExpression","argument","arguments","isThisExpression","isIdentifier","callee","getId","cloneNode","getterDeclared","params","isExpressionStatement","expression","setId","setterDeclared","methodId","buildPrivateNamesNodes","privateFieldsAsProperties","privateFieldsAsSymbols","state","initNodes","injectedIds","Set","value","isGetterOrSetter","init","callExpression","addHelper","stringLiteral","identifier","has","add","newExpression","annotateAsPure","push","template","statement","ast","privateNameVisitorFactory","visitor","nestedVisitor","visitors","environmentVisitor","Object","assign","privateNameVisitor","Class","path","visiblePrivateNames","redeclared","delete","traverse","skipKey","PrivateName","noDocumentAll","parentPath","isMemberExpression","property","isOptionalMemberExpression","includes","handle","unshadow","innerBinding","_scope","hasBinding","bindingIdentifierEquals","rename","parent","buildCheckInRHS","rhs","inRHSIsObject","privateInVisitor","BinaryExpression","operator","left","right","isPrivateName","classRef","replaceWith","readOnlyError","writeOnlyError","console","warn","buildUndefinedNode","buildStaticPrivateFieldAccess","expr","noUninitializedPrivateFieldAccess","memberExpression","autoInherits","fn","member","inherits","apply","privateNameHandlerSpec","memoise","count","object","memo","maybeGenerateMemoised","memoiser","receiver","privateName","cloneId","helperName","skipCheck","err","sequenceExpression","boundGet","assignmentExpression","destructureSet","helper","_unused","Error","getCall","ref","pop","setCall","buildCodeFrameError","args","computed","arrayExpression","slice","call","optimiseCall","optionalCall","privateNameHandlerLoose","BASE","REF","PROP","simpleSet","optionalCallExpression","transformPrivateNamesUsage","size","handler","memberExpressionToFunctions","buildPrivateFieldInitLoose","inheritPropComments","buildPrivateInstanceFieldInitSpec","inheritLoc","expressionStatement","thisExpression","buildPrivateStaticFieldInitSpec","variableDeclaration","variableDeclarator","buildPrivateStaticFieldInitSpecOld","buildPrivateMethodInitLoose","buildPrivateInstanceMethodInitSpec","buildPrivateAccessorInitialization","buildPrivateInstanceMethodInitialization","buildPublicFieldInitLoose","isLiteral","buildPublicFieldInitSpec","buildPrivateStaticMethodInitLoose","buildPrivateMethodDeclaration","generator","async","isGetter","isSetter","thisArg","thisRef","argumentsPath","thisContextVisitor","argumentsId","unshift","declId","functionDeclaration","Identifier","UnaryExpression","skipTransparentExprWrapperNodes","booleanLiteral","ThisExpression","needsClassRef","MetaProperty","meta","innerReferencesVisitor","ReferencedIdentifier","replaceThisContext","innerBindingRef","_state$thisRef","isNameOrLength","type","inheritLeadingComments","inheritInnerComments","original","start","end","loc","buildFieldsInitNodes","superRef","setPublicClassFields","constantSuper","classRefFlags","injectSuperRef","staticNodes","instanceNodes","lastInstanceNodeReturnsThis","pureStaticNodes","classBindingNode","getSuperRef","generateUidIdentifierBasedOnNode","classRefForInnerBinding","isClassProperty","assertFieldTransformed","isStaticBlock","isInstance","isPublic","isField","ReplaceSupers","methodPath","refToPreserve","getObjectRef","replace","replaced","blockBody","inheritsComments","filter","Boolean","wrapClass","leadingComments","remove","superClass","isClassExpression"],"sources":["../src/fields.ts"],"sourcesContent":["import { template, types as t } from \"@babel/core\";\nimport type { File, NodePath, Visitor, Scope } from \"@babel/core\";\nimport { visitors } from \"@babel/traverse\";\nimport ReplaceSupers from \"@babel/helper-replace-supers\";\nimport memberExpressionToFunctions from \"@babel/helper-member-expression-to-functions\";\nimport type {\n Handler,\n HandlerState,\n} from \"@babel/helper-member-expression-to-functions\";\nimport optimiseCall from \"@babel/helper-optimise-call-expression\";\nimport annotateAsPure from \"@babel/helper-annotate-as-pure\";\nimport { skipTransparentExprWrapperNodes } from \"@babel/helper-skip-transparent-expression-wrappers\";\n\nimport * as ts from \"./typescript.ts\";\n\ninterface PrivateNameMetadata {\n id: t.Identifier;\n static: boolean;\n method: boolean;\n getId?: t.Identifier;\n setId?: t.Identifier;\n methodId?: t.Identifier;\n initAdded?: boolean;Line truncated
|
||||
Generated
Vendored
+237
@@ -0,0 +1,237 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "FEATURES", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _features.FEATURES;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "buildCheckInRHS", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _fields.buildCheckInRHS;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "buildNamedEvaluationVisitor", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _decorators.buildNamedEvaluationVisitor;
|
||||
}
|
||||
});
|
||||
exports.createClassFeaturePlugin = createClassFeaturePlugin;
|
||||
Object.defineProperty(exports, "enableFeature", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _features.enableFeature;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "injectInitialization", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _misc.injectInitialization;
|
||||
}
|
||||
});
|
||||
var _core = require("@babel/core");
|
||||
var _semver = require("semver");
|
||||
var _fields = require("./fields.js");
|
||||
var _decorators = require("./decorators.js");
|
||||
var _decorators2 = require("./decorators-2018-09.js");
|
||||
var _misc = require("./misc.js");
|
||||
var _features = require("./features.js");
|
||||
var _typescript = require("./typescript.js");
|
||||
const versionKey = "@babel/plugin-class-features/version";
|
||||
function createClassFeaturePlugin({
|
||||
name,
|
||||
feature,
|
||||
loose,
|
||||
manipulateOptions,
|
||||
api,
|
||||
inherits,
|
||||
decoratorVersion
|
||||
}) {
|
||||
var _api$assumption;
|
||||
if (feature & _features.FEATURES.decorators) {
|
||||
if (decoratorVersion === "2023-11" || decoratorVersion === "2023-05" || decoratorVersion === "2023-01" || decoratorVersion === "2022-03" || decoratorVersion === "2021-12") {
|
||||
return (0, _decorators.default)(api, {
|
||||
loose
|
||||
}, decoratorVersion, inherits);
|
||||
}
|
||||
}
|
||||
api != null ? api : api = {
|
||||
assumption: () => void 0
|
||||
};
|
||||
const setPublicClassFields = api.assumption("setPublicClassFields");
|
||||
const privateFieldsAsSymbols = api.assumption("privateFieldsAsSymbols");
|
||||
const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties");
|
||||
const noUninitializedPrivateFieldAccess = (_api$assumption = api.assumption("noUninitializedPrivateFieldAccess")) != null ? _api$assumption : false;
|
||||
const constantSuper = api.assumption("constantSuper");
|
||||
const noDocumentAll = api.assumption("noDocumentAll");
|
||||
if (privateFieldsAsProperties && privateFieldsAsSymbols) {
|
||||
throw new Error(`Cannot enable both the "privateFieldsAsProperties" and ` + `"privateFieldsAsSymbols" assumptions as the same time.`);
|
||||
}
|
||||
const privateFieldsAsSymbolsOrProperties = privateFieldsAsProperties || privateFieldsAsSymbols;
|
||||
if (loose === true) {
|
||||
const explicit = [];
|
||||
if (setPublicClassFields !== undefined) {
|
||||
explicit.push(`"setPublicClassFields"`);
|
||||
}
|
||||
if (privateFieldsAsProperties !== undefined) {
|
||||
explicit.push(`"privateFieldsAsProperties"`);
|
||||
}
|
||||
if (privateFieldsAsSymbols !== undefined) {
|
||||
explicit.push(`"privateFieldsAsSymbols"`);
|
||||
}
|
||||
if (explicit.length !== 0) {
|
||||
console.warn(`[${name}]: You are using the "loose: true" option and you are` + ` explicitly setting a value for the ${explicit.join(" and ")}` + ` assumption${explicit.length > 1 ? "s" : ""}. The "loose" option` + ` can cause incompatibilities with the other class features` + ` plugins, so it's recommended that you replace it with the` + ` following top-level option:\n` + `\t"assumptions": {\n` + `\t\t"setPublicClassFields": true,\n` + `\t\t"privateFieldsAsSymbols": true\n` + `\t}`);
|
||||
}
|
||||
}
|
||||
return {
|
||||
name,
|
||||
manipulateOptions,
|
||||
inherits,
|
||||
pre(file) {
|
||||
(0, _features.enableFeature)(file, feature, loose);
|
||||
if (typeof file.get(versionKey) === "number") {
|
||||
file.set(versionKey, "7.29.7");
|
||||
return;
|
||||
}
|
||||
if (!file.get(versionKey) || _semver.lt(file.get(versionKey), "7.29.7")) {
|
||||
file.set(versionKey, "7.29.7");
|
||||
}
|
||||
},
|
||||
visitor: {
|
||||
Class(path, {
|
||||
file
|
||||
}) {
|
||||
if (file.get(versionKey) !== "7.29.7") return;
|
||||
if (!(0, _features.shouldTransform)(path, file)) return;
|
||||
const pathIsClassDeclaration = path.isClassDeclaration();
|
||||
if (pathIsClassDeclaration) (0, _typescript.assertFieldTransformed)(path);
|
||||
const loose = (0, _features.isLoose)(file, feature);
|
||||
let constructor;
|
||||
const isDecorated = (0, _decorators.hasDecorators)(path.node);
|
||||
const props = [];
|
||||
const elements = [];
|
||||
const computedPaths = [];
|
||||
const privateNames = new Set();
|
||||
const body = path.get("body");
|
||||
for (const path of body.get("body")) {
|
||||
if ((path.isClassProperty() || path.isClassMethod()) && path.node.computed) {
|
||||
computedPaths.push(path);
|
||||
}
|
||||
if (path.isPrivate()) {
|
||||
const {
|
||||
name
|
||||
} = path.node.key.id;
|
||||
const getName = `get ${name}`;
|
||||
const setName = `set ${name}`;
|
||||
if (path.isClassPrivateMethod()) {
|
||||
if (path.node.kind === "get") {
|
||||
if (privateNames.has(getName) || privateNames.has(name) && !privateNames.has(setName)) {
|
||||
throw path.buildCodeFrameError("Duplicate private field");
|
||||
}
|
||||
privateNames.add(getName).add(name);
|
||||
} else if (path.node.kind === "set") {
|
||||
if (privateNames.has(setName) || privateNames.has(name) && !privateNames.has(getName)) {
|
||||
throw path.buildCodeFrameError("Duplicate private field");
|
||||
}
|
||||
privateNames.add(setName).add(name);
|
||||
}
|
||||
} else {
|
||||
if (privateNames.has(name) && !privateNames.has(getName) && !privateNames.has(setName) || privateNames.has(name) && (privateNames.has(getName) || privateNames.has(setName))) {
|
||||
throw path.buildCodeFrameError("Duplicate private field");
|
||||
}
|
||||
privateNames.add(name);
|
||||
}
|
||||
}
|
||||
if (path.isClassMethod({
|
||||
kind: "constructor"
|
||||
})) {
|
||||
constructor = path;
|
||||
} else {
|
||||
elements.push(path);
|
||||
if (path.isProperty() || path.isPrivate() || path.isStaticBlock != null && path.isStaticBlock()) {
|
||||
props.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!props.length && !isDecorated) return;
|
||||
const innerBinding = path.node.id;
|
||||
let ref;
|
||||
if (!innerBinding || !pathIsClassDeclaration) {
|
||||
var _path$ensureFunctionN;
|
||||
(_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
|
||||
path.ensureFunctionName(false);
|
||||
ref = path.scope.generateUidIdentifier((innerBinding == null ? void 0 : innerBinding.name) || "Class");
|
||||
}
|
||||
const classRefForDefine = ref != null ? ref : _core.types.cloneNode(innerBinding);
|
||||
const privateNamesMap = (0, _fields.buildPrivateNamesMap)(classRefForDefine.name, privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose, props, file);
|
||||
const privateNamesNodes = (0, _fields.buildPrivateNamesNodes)(privateNamesMap, privateFieldsAsProperties != null ? privateFieldsAsProperties : loose, privateFieldsAsSymbols != null ? privateFieldsAsSymbols : false, file);
|
||||
(0, _fields.transformPrivateNamesUsage)(classRefForDefine, path, privateNamesMap, {
|
||||
privateFieldsAsProperties: privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose,
|
||||
noUninitializedPrivateFieldAccess,
|
||||
noDocumentAll,
|
||||
innerBinding
|
||||
}, file);
|
||||
let keysNodes, staticNodes, instanceNodes, lastInstanceNodeReturnsThis, pureStaticNodes, classBindingNode, wrapClass;
|
||||
if (isDecorated) {
|
||||
staticNodes = pureStaticNodes = keysNodes = [];
|
||||
({
|
||||
instanceNodes,
|
||||
wrapClass
|
||||
} = (0, _decorators2.buildDecoratedClass)(classRefForDefine, path, elements, file));
|
||||
} else {
|
||||
keysNodes = (0, _misc.extractComputedKeys)(path, computedPaths, file);
|
||||
({
|
||||
staticNodes,
|
||||
pureStaticNodes,
|
||||
instanceNodes,
|
||||
lastInstanceNodeReturnsThis,
|
||||
classBindingNode,
|
||||
wrapClass
|
||||
} = (0, _fields.buildFieldsInitNodes)(ref, path.node.superClass, props, privateNamesMap, file, setPublicClassFields != null ? setPublicClassFields : loose, privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose, noUninitializedPrivateFieldAccess, constantSuper != null ? constantSuper : loose, innerBinding));
|
||||
}
|
||||
if (instanceNodes.length > 0) {
|
||||
(0, _misc.injectInitialization)(path, constructor, instanceNodes, (referenceVisitor, state) => {
|
||||
if (isDecorated) return;
|
||||
for (const prop of props) {
|
||||
if (_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node) || prop.node.static) continue;
|
||||
prop.traverse(referenceVisitor, state);
|
||||
}
|
||||
}, lastInstanceNodeReturnsThis);
|
||||
}
|
||||
const wrappedPath = wrapClass(path);
|
||||
wrappedPath.insertBefore([...privateNamesNodes, ...keysNodes]);
|
||||
if (staticNodes.length > 0) {
|
||||
wrappedPath.insertAfter(staticNodes);
|
||||
}
|
||||
if (pureStaticNodes.length > 0) {
|
||||
wrappedPath.find(parent => parent.isStatement() || parent.isDeclaration()).insertAfter(pureStaticNodes);
|
||||
}
|
||||
if (classBindingNode != null && pathIsClassDeclaration) {
|
||||
wrappedPath.insertAfter(classBindingNode);
|
||||
}
|
||||
},
|
||||
ExportDefaultDeclaration(path, {
|
||||
file
|
||||
}) {
|
||||
if (file.get(versionKey) !== "7.29.7") return;
|
||||
const decl = path.get("declaration");
|
||||
if (decl.isClassDeclaration() && (0, _decorators.hasDecorators)(decl.node)) {
|
||||
if (decl.node.id) {
|
||||
var _path$splitExportDecl;
|
||||
(_path$splitExportDecl = path.splitExportDeclaration) != null ? _path$splitExportDecl : path.splitExportDeclaration = require("@babel/traverse").NodePath.prototype.splitExportDeclaration;
|
||||
path.splitExportDeclaration();
|
||||
} else {
|
||||
decl.node.type = "ClassExpression";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=index.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_core","require","_semver","_fields","_decorators","_decorators2","_misc","_features","_typescript","versionKey","createClassFeaturePlugin","name","feature","loose","manipulateOptions","api","inherits","decoratorVersion","_api$assumption","FEATURES","decorators","createDecoratorTransform","assumption","setPublicClassFields","privateFieldsAsSymbols","privateFieldsAsProperties","noUninitializedPrivateFieldAccess","constantSuper","noDocumentAll","Error","privateFieldsAsSymbolsOrProperties","explicit","undefined","push","length","console","warn","join","pre","file","enableFeature","get","set","semver","lt","visitor","Class","path","shouldTransform","pathIsClassDeclaration","isClassDeclaration","assertFieldTransformed","isLoose","constructor","isDecorated","hasDecorators","node","props","elements","computedPaths","privateNames","Set","body","isClassProperty","isClassMethod","computed","isPrivate","key","id","getName","setName","isClassPrivateMethod","kind","has","buildCodeFrameError","add","isProperty","isStaticBlock","innerBinding","ref","_path$ensureFunctionN","ensureFunctionName","NodePath","prototype","scope","generateUidIdentifier","classRefForDefine","t","cloneNode","privateNamesMap","buildPrivateNamesMap","privateNamesNodes","buildPrivateNamesNodes","transformPrivateNamesUsage","keysNodes","staticNodes","instanceNodes","lastInstanceNodeReturnsThis","pureStaticNodes","classBindingNode","wrapClass","buildDecoratedClass","extractComputedKeys","buildFieldsInitNodes","superClass","injectInitialization","referenceVisitor","state","prop","static","traverse","wrappedPath","insertBefore","insertAfter","find","parent","isStatement","isDeclaration","ExportDefaultDeclaration","decl","_path$splitExportDecl","splitExportDeclaration","type"],"sources":["../src/index.ts"],"sourcesContent":["import { types as t } from \"@babel/core\";\nimport type { PluginAPI, PluginObject, NodePath } from \"@babel/core\";\n\nimport semver from \"semver\";\n\nimport {\n buildPrivateNamesNodes,\n buildPrivateNamesMap,\n transformPrivateNamesUsage,\n buildFieldsInitNodes,\n buildCheckInRHS,\n} from \"./fields.ts\";\nimport type { PropPath } from \"./fields.ts\";\nimport createDecoratorTransform, {\n hasDecorators,\n buildNamedEvaluationVisitor,\n} from \"./decorators.ts\";\nimport type { DecoratorVersionKind } from \"./decorators.ts\";\nimport { buildDecoratedClass } from \"./decorators-2018-09.ts\" with { if: \"!process.env.BABEL_8_BREAKING\" };\nimport { injectInitialization, extractComputedKeys } from \"./misc.ts\";\nimport {\n enableFeature,\n FEATURES,\n isLoose,\n shouldTransform,\n} from \"./features.ts\";\nimport { assertFieldTransformed } from \"./typescript.ts\";\n\nexport {\n FEATURES,\n enableFeature,\n injectInitialization,\n buildCheckInRHS,\n buildNamedEvaluationVisitor,\n};\n\nconst versionKey = \"@babel/plugin-class-features/version\";\n\ninterface Options {\n name: string;\n feature: number;\n loose?: boolean;\n inherits?: PluginObject[\"inherits\"];\n manipulateOptions?: PluginObject[\"manipulateOptions\"];\n api?: PluginAPI;\n decoratorVersion?: DecoratorVersionKind | \"2018-09\";\n}\n\nexport function createClassFeaturePlugin({\n name,\n feature,\n loose,\n manipulateOptions,\n api,\n inherits,\n decoratorVersion,\n}: Options): PluginObject {\n if (feature & FEATURES.decorators) {\n if (process.env.BABEL_8_BREAKING) {\n return createDecoratorTransform(api, { loose }, \"2023-11\", inherits);\n } else {\n if (\n decoratorVersion === \"2023-11\" ||\n decoratorVersion === \"2023-05\" ||\n decoratorVersion === \"2023-01\" ||\n decoratorVersion === \"2022-03\" ||\n decoratorVersion === \"2021-12\"\n ) {\n return createDecoratorTransform(\n api,\n { loose },\n decoratorVersion,\n inherits,\n );\n }\n }\n }\n if (!process.env.BABEL_8_BREAKING) {\n api ??= { assumption: () => void 0 as any } as any;\n }\n const setPublicClassFields = api.assumption(\"setPublicClassFields\");\n const privateFieldsAsSymbols = api.assumption(\"privateFieldsAsSymbols\");\n const privateFieldsAsProperties = api.assumption(\"privateFieldsAsProperties\");\n const noUninitializedPrivateFieldAccess =\n api.assumption(\"noUninitializedPrivateFieldAccess\") ?? false;\n const constantSuper = api.assumption(\"constantSuper\");\n const noDocumentAll = api.assumption(\"noDocumentAll\");\n\n if (privateFieldsAsProperties && privateFieldsAsSymbols) {\n throw new Error(\n `Cannot enable both the \"privateFieldsAsProperties\" and ` +\n `\"privateFieldsAsSymbols\" assumptions as the same time.`,\n );\n }\n const privateFieldsAsSymbolsOrProperties =\n privateFieldsAsProperties || privateFieldsAsSymbols;\n\n if (loose === true) {\n type AssumptionName = Parameters<PluginAPI[\"assumption\"]>[0];\n const explicit: `\"${AssumptionName}\"`[] = [];\n\n if (sLine truncated
|
||||
Generated
Vendored
+136
@@ -0,0 +1,136 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.extractComputedKeys = extractComputedKeys;
|
||||
exports.injectInitialization = injectInitialization;
|
||||
exports.memoiseComputedKey = memoiseComputedKey;
|
||||
var _core = require("@babel/core");
|
||||
var _traverse = require("@babel/traverse");
|
||||
const findBareSupers = _traverse.visitors.environmentVisitor({
|
||||
Super(path) {
|
||||
const {
|
||||
node,
|
||||
parentPath
|
||||
} = path;
|
||||
if (parentPath.isCallExpression({
|
||||
callee: node
|
||||
})) {
|
||||
this.push(parentPath);
|
||||
}
|
||||
}
|
||||
});
|
||||
const referenceVisitor = {
|
||||
"TSTypeAnnotation|TypeAnnotation"(path) {
|
||||
path.skip();
|
||||
},
|
||||
ReferencedIdentifier(path, {
|
||||
scope
|
||||
}) {
|
||||
if (scope.hasOwnBinding(path.node.name)) {
|
||||
scope.rename(path.node.name);
|
||||
path.skip();
|
||||
}
|
||||
}
|
||||
};
|
||||
function handleClassTDZ(path, state) {
|
||||
if (state.classBinding && state.classBinding === path.scope.getBinding(path.node.name)) {
|
||||
const classNameTDZError = state.file.addHelper("classNameTDZError");
|
||||
const throwNode = _core.types.callExpression(classNameTDZError, [_core.types.stringLiteral(path.node.name)]);
|
||||
path.replaceWith(_core.types.sequenceExpression([throwNode, path.node]));
|
||||
path.skip();
|
||||
}
|
||||
}
|
||||
const classFieldDefinitionEvaluationTDZVisitor = {
|
||||
ReferencedIdentifier: handleClassTDZ,
|
||||
"TSTypeAnnotation|TypeAnnotation"(path) {
|
||||
path.skip();
|
||||
}
|
||||
};
|
||||
function injectInitialization(path, constructor, nodes, renamer, lastReturnsThis) {
|
||||
if (!nodes.length) return;
|
||||
const isDerived = !!path.node.superClass;
|
||||
if (!constructor) {
|
||||
const newConstructor = _core.types.classMethod("constructor", _core.types.identifier("constructor"), [], _core.types.blockStatement([]));
|
||||
if (isDerived) {
|
||||
newConstructor.params = [_core.types.restElement(_core.types.identifier("args"))];
|
||||
newConstructor.body.body.push(_core.template.statement.ast`super(...args)`);
|
||||
}
|
||||
[constructor] = path.get("body").unshiftContainer("body", newConstructor);
|
||||
}
|
||||
if (renamer) {
|
||||
renamer(referenceVisitor, {
|
||||
scope: constructor.scope
|
||||
});
|
||||
}
|
||||
if (isDerived) {
|
||||
const bareSupers = [];
|
||||
constructor.traverse(findBareSupers, bareSupers);
|
||||
let isFirst = true;
|
||||
for (const bareSuper of bareSupers) {
|
||||
if (isFirst) {
|
||||
isFirst = false;
|
||||
} else {
|
||||
nodes = nodes.map(n => _core.types.cloneNode(n));
|
||||
}
|
||||
if (!bareSuper.parentPath.isExpressionStatement()) {
|
||||
const allNodes = [bareSuper.node, ...nodes.map(n => _core.types.toExpression(n))];
|
||||
if (!lastReturnsThis) allNodes.push(_core.types.thisExpression());
|
||||
bareSuper.replaceWith(_core.types.sequenceExpression(allNodes));
|
||||
} else {
|
||||
bareSuper.insertAfter(nodes);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
constructor.get("body").unshiftContainer("body", nodes);
|
||||
}
|
||||
}
|
||||
function memoiseComputedKey(keyNode, scope, hint) {
|
||||
const isUidReference = _core.types.isIdentifier(keyNode) && scope.hasUid(keyNode.name);
|
||||
if (isUidReference) {
|
||||
return;
|
||||
}
|
||||
const isMemoiseAssignment = _core.types.isAssignmentExpression(keyNode, {
|
||||
operator: "="
|
||||
}) && _core.types.isIdentifier(keyNode.left) && scope.hasUid(keyNode.left.name);
|
||||
if (isMemoiseAssignment) {
|
||||
return _core.types.cloneNode(keyNode);
|
||||
} else {
|
||||
const ident = _core.types.identifier(hint);
|
||||
scope.push({
|
||||
id: ident,
|
||||
kind: "let"
|
||||
});
|
||||
return _core.types.assignmentExpression("=", _core.types.cloneNode(ident), keyNode);
|
||||
}
|
||||
}
|
||||
function extractComputedKeys(path, computedPaths, file) {
|
||||
const {
|
||||
scope
|
||||
} = path;
|
||||
const declarations = [];
|
||||
const state = {
|
||||
classBinding: path.node.id && scope.getBinding(path.node.id.name),
|
||||
file
|
||||
};
|
||||
for (const computedPath of computedPaths) {
|
||||
const computedKey = computedPath.get("key");
|
||||
if (computedKey.isReferencedIdentifier()) {
|
||||
handleClassTDZ(computedKey, state);
|
||||
} else {
|
||||
computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);
|
||||
}
|
||||
const computedNode = computedPath.node;
|
||||
if (!computedKey.isConstantExpression()) {
|
||||
const assignment = memoiseComputedKey(computedKey.node, scope, scope.generateUidBasedOnNode(computedKey.node));
|
||||
if (assignment) {
|
||||
declarations.push(_core.types.expressionStatement(assignment));
|
||||
computedNode.key = _core.types.cloneNode(assignment.left);
|
||||
}
|
||||
}
|
||||
}
|
||||
return declarations;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=misc.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_core","require","_traverse","findBareSupers","visitors","environmentVisitor","Super","path","node","parentPath","isCallExpression","callee","push","referenceVisitor","TSTypeAnnotation|TypeAnnotation","skip","ReferencedIdentifier","scope","hasOwnBinding","name","rename","handleClassTDZ","state","classBinding","getBinding","classNameTDZError","file","addHelper","throwNode","t","callExpression","stringLiteral","replaceWith","sequenceExpression","classFieldDefinitionEvaluationTDZVisitor","injectInitialization","constructor","nodes","renamer","lastReturnsThis","length","isDerived","superClass","newConstructor","classMethod","identifier","blockStatement","params","restElement","body","template","statement","ast","get","unshiftContainer","bareSupers","traverse","isFirst","bareSuper","map","n","cloneNode","isExpressionStatement","allNodes","toExpression","thisExpression","insertAfter","memoiseComputedKey","keyNode","hint","isUidReference","isIdentifier","hasUid","isMemoiseAssignment","isAssignmentExpression","operator","left","ident","id","kind","assignmentExpression","extractComputedKeys","computedPaths","declarations","computedPath","computedKey","isReferencedIdentifier","computedNode","isConstantExpression","assignment","generateUidBasedOnNode","expressionStatement","key"],"sources":["../src/misc.ts"],"sourcesContent":["import { template, types as t } from \"@babel/core\";\nimport type { File, NodePath, Scope, Visitor } from \"@babel/core\";\nimport { visitors } from \"@babel/traverse\";\n\nconst findBareSupers = visitors.environmentVisitor<\n NodePath<t.CallExpression>[]\n>({\n Super(path) {\n const { node, parentPath } = path;\n if (parentPath.isCallExpression({ callee: node })) {\n this.push(parentPath);\n }\n },\n});\n\nconst referenceVisitor: Visitor<{ scope: Scope }> = {\n \"TSTypeAnnotation|TypeAnnotation\"(\n path: NodePath<t.TSTypeAnnotation | t.TypeAnnotation>,\n ) {\n path.skip();\n },\n\n ReferencedIdentifier(path: NodePath<t.Identifier>, { scope }) {\n if (scope.hasOwnBinding(path.node.name)) {\n scope.rename(path.node.name);\n path.skip();\n }\n },\n};\n\ntype HandleClassTDZState = {\n classBinding: Scope.Binding;\n file: File;\n};\n\nfunction handleClassTDZ(\n path: NodePath<t.Identifier>,\n state: HandleClassTDZState,\n) {\n if (\n state.classBinding &&\n state.classBinding === path.scope.getBinding(path.node.name)\n ) {\n const classNameTDZError = state.file.addHelper(\"classNameTDZError\");\n const throwNode = t.callExpression(classNameTDZError, [\n t.stringLiteral(path.node.name),\n ]);\n\n path.replaceWith(t.sequenceExpression([throwNode, path.node]));\n path.skip();\n }\n}\n\nconst classFieldDefinitionEvaluationTDZVisitor: Visitor<HandleClassTDZState> = {\n ReferencedIdentifier: handleClassTDZ,\n \"TSTypeAnnotation|TypeAnnotation\"(path) {\n path.skip();\n },\n};\n\ninterface RenamerState {\n scope: Scope;\n}\n\nexport function injectInitialization(\n path: NodePath<t.Class>,\n constructor: NodePath<t.ClassMethod> | undefined,\n nodes: t.ExpressionStatement[],\n renamer?: (visitor: Visitor<RenamerState>, state: RenamerState) => void,\n lastReturnsThis?: boolean,\n) {\n if (!nodes.length) return;\n\n const isDerived = !!path.node.superClass;\n\n if (!constructor) {\n const newConstructor = t.classMethod(\n \"constructor\",\n t.identifier(\"constructor\"),\n [],\n t.blockStatement([]),\n );\n\n if (isDerived) {\n newConstructor.params = [t.restElement(t.identifier(\"args\"))];\n newConstructor.body.body.push(template.statement.ast`super(...args)`);\n }\n\n [constructor] = path\n .get(\"body\")\n .unshiftContainer(\"body\", newConstructor) as NodePath<t.ClassMethod>[];\n }\n\n if (renamer) {\n renamer(referenceVisitor, { scope: constructor.scope });\n }\n\n if (isDerived) {\n const bareSupers: NodePath<t.CallExpression>[] = [];\n constructor.traverse(findBareSupers, bareSupers);\n let isFirst = true;\n for (const bareSuper of bareSupers) {\n if (isFirst) {\n isFirst = false;\n } else {\n nodes = nodes.map(n => t.cloneNode(n));\n }\n if (!bareSuper.parentPath.isExpressionStatement()) {\n const allNodes: t.Expression[] = [\n bareSuper.node,\n ...nodes.map(n => t.toExpression(n)),\n ];\n if (!lastReturnsThis) allNodes.push(t.thisExpression());\n bareSuper.replaceWith(t.sequenceExpression(allNodes));\n } else {\n bareSuper.insertAfter(nodes);\n }\n }\n } else {\n constructor.get(\"body\").unshiftContainer(\"body\", nodes);\n }\n}\n\ntype ComputedKeyAssignmentExpression = t.AssignmentExpression & {\n left: t.Identifier;\n};\n\n/**\n * Try to memoise a computed key.\n * It returns undefined when the computed key is an uid reference, otherwise\n * an assignment expression `memoiserId = computed key`\n * @exporLine truncated
|
||||
Generated
Vendored
+13
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.assertFieldTransformed = assertFieldTransformed;
|
||||
function assertFieldTransformed(path) {
|
||||
if (path.node.declare || false) {
|
||||
throw path.buildCodeFrameError(`TypeScript 'declare' fields must first be transformed by ` + `@babel/plugin-transform-typescript.\n` + `If you have already enabled that plugin (or '@babel/preset-typescript'), make sure ` + `that it runs before any plugin related to additional class features:\n` + ` - @babel/plugin-transform-class-properties\n` + ` - @babel/plugin-transform-private-methods\n` + ` - @babel/plugin-proposal-decorators`);
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=typescript.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["assertFieldTransformed","path","node","declare","buildCodeFrameError"],"sources":["../src/typescript.ts"],"sourcesContent":["import type { NodePath, types as t } from \"@babel/core\";\n\nexport function assertFieldTransformed(\n path: NodePath<t.ClassProperty | t.ClassDeclaration>,\n) {\n if (\n path.node.declare ||\n (process.env.BABEL_8_BREAKING\n ? path.isClassProperty({ definite: true })\n : false)\n ) {\n throw path.buildCodeFrameError(\n `TypeScript 'declare' fields must first be transformed by ` +\n `@babel/plugin-transform-typescript.\\n` +\n `If you have already enabled that plugin (or '@babel/preset-typescript'), make sure ` +\n `that it runs before any plugin related to additional class features:\\n` +\n ` - @babel/plugin-transform-class-properties\\n` +\n ` - @babel/plugin-transform-private-methods\\n` +\n ` - @babel/plugin-proposal-decorators`,\n );\n }\n}\n"],"mappings":";;;;;;AAEO,SAASA,sBAAsBA,CACpCC,IAAoD,EACpD;EACA,IACEA,IAAI,CAACC,IAAI,CAACC,OAAO,IAGb,KAAM,EACV;IACA,MAAMF,IAAI,CAACG,mBAAmB,CAC5B,2DAA2D,GACzD,uCAAuC,GACvC,qFAAqF,GACrF,wEAAwE,GACxE,+CAA+C,GAC/C,8CAA8C,GAC9C,sCACJ,CAAC;EACH;AACF","ignoreList":[]}
|
||||
Reference in new issue
Block a user