tahamajs/IE / Projects /front /node_modules /@babel /plugin-transform-optional-chaining /lib /index.js
| ; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| var helperPluginUtils = require('@babel/helper-plugin-utils'); | |
| var core = require('@babel/core'); | |
| var helperSkipTransparentExpressionWrappers = require('@babel/helper-skip-transparent-expression-wrappers'); | |
| function willPathCastToBoolean(path) { | |
| const maybeWrapped = findOutermostTransparentParent(path); | |
| const { | |
| node, | |
| parentPath | |
| } = maybeWrapped; | |
| if (parentPath.isLogicalExpression()) { | |
| const { | |
| operator, | |
| right | |
| } = parentPath.node; | |
| if (operator === "&&" || operator === "||" || operator === "??" && node === right) { | |
| return willPathCastToBoolean(parentPath); | |
| } | |
| } | |
| if (parentPath.isSequenceExpression()) { | |
| const { | |
| expressions | |
| } = parentPath.node; | |
| if (expressions[expressions.length - 1] === node) { | |
| return willPathCastToBoolean(parentPath); | |
| } else { | |
| return true; | |
| } | |
| } | |
| return parentPath.isConditional({ | |
| test: node | |
| }) || parentPath.isUnaryExpression({ | |
| operator: "!" | |
| }) || parentPath.isForStatement({ | |
| test: node | |
| }) || parentPath.isWhile({ | |
| test: node | |
| }); | |
| } | |
| function findOutermostTransparentParent(path) { | |
| let maybeWrapped = path; | |
| path.findParent(p => { | |
| if (!helperSkipTransparentExpressionWrappers.isTransparentExprWrapper(p.node)) return true; | |
| maybeWrapped = p; | |
| }); | |
| return maybeWrapped; | |
| } | |
| const last = arr => arr[arr.length - 1]; | |
| function isSimpleMemberExpression(expression) { | |
| expression = helperSkipTransparentExpressionWrappers.skipTransparentExprWrapperNodes(expression); | |
| return core.types.isIdentifier(expression) || core.types.isSuper(expression) || core.types.isMemberExpression(expression) && !expression.computed && isSimpleMemberExpression(expression.object); | |
| } | |
| function needsMemoize(path) { | |
| let optionalPath = path; | |
| const { | |
| scope | |
| } = path; | |
| while (optionalPath.isOptionalMemberExpression() || optionalPath.isOptionalCallExpression()) { | |
| const { | |
| node | |
| } = optionalPath; | |
| const childPath = helperSkipTransparentExpressionWrappers.skipTransparentExprWrappers(optionalPath.isOptionalMemberExpression() ? optionalPath.get("object") : optionalPath.get("callee")); | |
| if (node.optional) { | |
| return !scope.isStatic(childPath.node); | |
| } | |
| optionalPath = childPath; | |
| } | |
| } | |
| const NULLISH_CHECK = core.template.expression(`%%check%% === null || %%ref%% === void 0`); | |
| const NULLISH_CHECK_NO_DDA = core.template.expression(`%%check%% == null`); | |
| const NULLISH_CHECK_NEG = core.template.expression(`%%check%% !== null && %%ref%% !== void 0`); | |
| const NULLISH_CHECK_NO_DDA_NEG = core.template.expression(`%%check%% != null`); | |
| function transformOptionalChain(path, { | |
| pureGetters, | |
| noDocumentAll | |
| }, replacementPath, ifNullish, wrapLast) { | |
| const { | |
| scope | |
| } = path; | |
| if (scope.path.isPattern() && needsMemoize(path)) { | |
| replacementPath.replaceWith(core.template.expression.ast`(() => ${replacementPath.node})()`); | |
| return; | |
| } | |
| const optionals = []; | |
| let optionalPath = path; | |
| while (optionalPath.isOptionalMemberExpression() || optionalPath.isOptionalCallExpression()) { | |
| const { | |
| node | |
| } = optionalPath; | |
| if (node.optional) { | |
| optionals.push(node); | |
| } | |
| if (optionalPath.isOptionalMemberExpression()) { | |
| optionalPath.node.type = "MemberExpression"; | |
| optionalPath = helperSkipTransparentExpressionWrappers.skipTransparentExprWrappers(optionalPath.get("object")); | |
| } else if (optionalPath.isOptionalCallExpression()) { | |
| optionalPath.node.type = "CallExpression"; | |
| optionalPath = helperSkipTransparentExpressionWrappers.skipTransparentExprWrappers(optionalPath.get("callee")); | |
| } | |
| } | |
| if (optionals.length === 0) { | |
| return; | |
| } | |
| const checks = []; | |
| let tmpVar; | |
| for (let i = optionals.length - 1; i >= 0; i--) { | |
| const node = optionals[i]; | |
| const isCall = core.types.isCallExpression(node); | |
| const chainWithTypes = isCall ? node.callee : node.object; | |
| const chain = helperSkipTransparentExpressionWrappers.skipTransparentExprWrapperNodes(chainWithTypes); | |
| let ref; | |
| let check; | |
| if (isCall && core.types.isIdentifier(chain, { | |
| name: "eval" | |
| })) { | |
| check = ref = chain; | |
| node.callee = core.types.sequenceExpression([core.types.numericLiteral(0), ref]); | |
| } else if (pureGetters && isCall && isSimpleMemberExpression(chain)) { | |
| check = ref = node.callee; | |
| } else if (scope.isStatic(chain)) { | |
| check = ref = chainWithTypes; | |
| } else { | |
| if (!tmpVar || isCall) { | |
| tmpVar = scope.generateUidIdentifierBasedOnNode(chain); | |
| scope.push({ | |
| id: core.types.cloneNode(tmpVar) | |
| }); | |
| } | |
| ref = tmpVar; | |
| check = core.types.assignmentExpression("=", core.types.cloneNode(tmpVar), chainWithTypes); | |
| if (isCall) { | |
| node.callee = ref; | |
| } else { | |
| node.object = ref; | |
| } | |
| } | |
| if (isCall && core.types.isMemberExpression(chain)) { | |
| if (pureGetters && isSimpleMemberExpression(chain)) { | |
| node.callee = chainWithTypes; | |
| } else { | |
| const { | |
| object | |
| } = chain; | |
| let context; | |
| if (core.types.isSuper(object)) { | |
| context = core.types.thisExpression(); | |
| } else { | |
| const memoized = scope.maybeGenerateMemoised(object); | |
| if (memoized) { | |
| context = memoized; | |
| chain.object = core.types.assignmentExpression("=", memoized, object); | |
| } else { | |
| context = object; | |
| } | |
| } | |
| node.arguments.unshift(core.types.cloneNode(context)); | |
| node.callee = core.types.memberExpression(node.callee, core.types.identifier("call")); | |
| } | |
| } | |
| const data = { | |
| check: core.types.cloneNode(check), | |
| ref: core.types.cloneNode(ref) | |
| }; | |
| Object.defineProperty(data, "ref", { | |
| enumerable: false | |
| }); | |
| checks.push(data); | |
| } | |
| let result = replacementPath.node; | |
| if (wrapLast) result = wrapLast(result); | |
| const ifNullishBoolean = core.types.isBooleanLiteral(ifNullish); | |
| const ifNullishFalse = ifNullishBoolean && ifNullish.value === false; | |
| const ifNullishVoid = !ifNullishBoolean && core.types.isUnaryExpression(ifNullish, { | |
| operator: "void" | |
| }); | |
| const isEvaluationValueIgnored = core.types.isExpressionStatement(replacementPath.parent) && !replacementPath.isCompletionRecord() || core.types.isSequenceExpression(replacementPath.parent) && last(replacementPath.parent.expressions) !== replacementPath.node; | |
| const tpl = ifNullishFalse ? noDocumentAll ? NULLISH_CHECK_NO_DDA_NEG : NULLISH_CHECK_NEG : noDocumentAll ? NULLISH_CHECK_NO_DDA : NULLISH_CHECK; | |
| const logicalOp = ifNullishFalse ? "&&" : "||"; | |
| const check = checks.map(tpl).reduce((expr, check) => core.types.logicalExpression(logicalOp, expr, check)); | |
| replacementPath.replaceWith(ifNullishBoolean || ifNullishVoid && isEvaluationValueIgnored ? core.types.logicalExpression(logicalOp, check, result) : core.types.conditionalExpression(check, ifNullish, result)); | |
| } | |
| function transform(path, assumptions) { | |
| const { | |
| scope | |
| } = path; | |
| const maybeWrapped = findOutermostTransparentParent(path); | |
| const { | |
| parentPath | |
| } = maybeWrapped; | |
| if (parentPath.isUnaryExpression({ | |
| operator: "delete" | |
| })) { | |
| transformOptionalChain(path, assumptions, parentPath, core.types.booleanLiteral(true)); | |
| } else { | |
| let wrapLast; | |
| if (parentPath.isCallExpression({ | |
| callee: maybeWrapped.node | |
| }) && path.isOptionalMemberExpression()) { | |
| wrapLast = replacement => { | |
| const object = helperSkipTransparentExpressionWrappers.skipTransparentExprWrapperNodes(replacement.object); | |
| let baseRef; | |
| if (!assumptions.pureGetters || !isSimpleMemberExpression(object)) { | |
| baseRef = scope.maybeGenerateMemoised(object); | |
| if (baseRef) { | |
| replacement.object = core.types.assignmentExpression("=", baseRef, object); | |
| } | |
| } | |
| return core.types.callExpression(core.types.memberExpression(replacement, core.types.identifier("bind")), [core.types.cloneNode(baseRef != null ? baseRef : object)]); | |
| }; | |
| } | |
| transformOptionalChain(path, assumptions, path, willPathCastToBoolean(maybeWrapped) ? core.types.booleanLiteral(false) : scope.buildUndefinedNode(), wrapLast); | |
| } | |
| } | |
| var index = helperPluginUtils.declare((api, options) => { | |
| var _api$assumption, _api$assumption2; | |
| api.assertVersion("^7.0.0-0 || ^8.0.0-0 || >8.0.0-alpha <8.0.0-beta"); | |
| const { | |
| loose = false | |
| } = options; | |
| const noDocumentAll = (_api$assumption = api.assumption("noDocumentAll")) != null ? _api$assumption : loose; | |
| const pureGetters = (_api$assumption2 = api.assumption("pureGetters")) != null ? _api$assumption2 : loose; | |
| return { | |
| name: "transform-optional-chaining", | |
| manipulateOptions: (_, parser) => parser.plugins.push("optionalChaining"), | |
| visitor: { | |
| "OptionalCallExpression|OptionalMemberExpression"(path) { | |
| transform(path, { | |
| noDocumentAll, | |
| pureGetters | |
| }); | |
| } | |
| } | |
| }; | |
| }); | |
| exports.default = index; | |
| exports.transform = transform; | |
| exports.transformOptionalChain = transformOptionalChain; | |
| //# sourceMappingURL=index.js.map | |
Xet Storage Details
- Size:
- 9.21 kB
- Xet hash:
- 5c5a84664e9463fe10d087ebd29a33294ddadd4942574cd4c52e9d9468604699
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.