| ; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = convertFunctionParams; | |
| var _core = require("@babel/core"); | |
| var _shadowUtils = require("./shadow-utils.js"); | |
| const buildDefaultParam = _core.template.statement(` | |
| let VARIABLE_NAME = | |
| arguments.length > ARGUMENT_KEY && arguments[ARGUMENT_KEY] !== undefined ? | |
| arguments[ARGUMENT_KEY] | |
| : | |
| DEFAULT_VALUE; | |
| `); | |
| const buildLooseDefaultParam = _core.template.statement(` | |
| if (ASSIGNMENT_IDENTIFIER === UNDEFINED) { | |
| ASSIGNMENT_IDENTIFIER = DEFAULT_VALUE; | |
| } | |
| `); | |
| const buildLooseDestructuredDefaultParam = _core.template.statement(` | |
| let ASSIGNMENT_IDENTIFIER = PARAMETER_NAME === UNDEFINED ? DEFAULT_VALUE : PARAMETER_NAME ; | |
| `); | |
| const buildSafeArgumentsAccess = _core.template.statement(` | |
| let $0 = arguments.length > $1 ? arguments[$1] : undefined; | |
| `); | |
| function convertFunctionParams(path, ignoreFunctionLength, shouldTransformParam, replaceRestElement) { | |
| const params = path.get("params"); | |
| const isSimpleParameterList = params.every(param => param.isIdentifier()); | |
| if (isSimpleParameterList) return false; | |
| const { | |
| node, | |
| scope | |
| } = path; | |
| const body = []; | |
| const shadowedParams = new Set(); | |
| for (const param of params) { | |
| (0, _shadowUtils.collectShadowedParamsNames)(param, scope, shadowedParams); | |
| } | |
| const state = { | |
| needsOuterBinding: false, | |
| scope | |
| }; | |
| if (shadowedParams.size === 0) { | |
| for (const param of params) { | |
| if (!param.isIdentifier()) param.traverse(_shadowUtils.iifeVisitor, state); | |
| if (state.needsOuterBinding) break; | |
| } | |
| } | |
| let firstOptionalIndex = null; | |
| for (let i = 0; i < params.length; i++) { | |
| const param = params[i]; | |
| if (shouldTransformParam && !shouldTransformParam(i)) { | |
| continue; | |
| } | |
| const transformedRestNodes = []; | |
| if (replaceRestElement) { | |
| replaceRestElement(path, param, transformedRestNodes); | |
| } | |
| const paramIsAssignmentPattern = param.isAssignmentPattern(); | |
| if (paramIsAssignmentPattern && (ignoreFunctionLength || _core.types.isMethod(node, { | |
| kind: "set" | |
| }))) { | |
| const left = param.get("left"); | |
| const right = param.get("right"); | |
| const undefinedNode = scope.buildUndefinedNode(); | |
| if (left.isIdentifier()) { | |
| body.push(buildLooseDefaultParam({ | |
| ASSIGNMENT_IDENTIFIER: _core.types.cloneNode(left.node), | |
| DEFAULT_VALUE: right.node, | |
| UNDEFINED: undefinedNode | |
| })); | |
| param.replaceWith(left.node); | |
| } else if (left.isObjectPattern() || left.isArrayPattern()) { | |
| const paramName = scope.generateUidIdentifier(); | |
| body.push(buildLooseDestructuredDefaultParam({ | |
| ASSIGNMENT_IDENTIFIER: left.node, | |
| DEFAULT_VALUE: right.node, | |
| PARAMETER_NAME: _core.types.cloneNode(paramName), | |
| UNDEFINED: undefinedNode | |
| })); | |
| param.replaceWith(paramName); | |
| } | |
| } else if (paramIsAssignmentPattern) { | |
| if (firstOptionalIndex === null) firstOptionalIndex = i; | |
| const left = param.get("left"); | |
| const right = param.get("right"); | |
| const defNode = buildDefaultParam({ | |
| VARIABLE_NAME: left.node, | |
| DEFAULT_VALUE: right.node, | |
| ARGUMENT_KEY: _core.types.numericLiteral(i) | |
| }); | |
| body.push(defNode); | |
| } else if (firstOptionalIndex !== null) { | |
| const defNode = buildSafeArgumentsAccess([param.node, _core.types.numericLiteral(i)]); | |
| body.push(defNode); | |
| } else if (param.isObjectPattern() || param.isArrayPattern()) { | |
| const uid = path.scope.generateUidIdentifier("ref"); | |
| uid.typeAnnotation = param.node.typeAnnotation; | |
| const defNode = _core.types.variableDeclaration("let", [_core.types.variableDeclarator(param.node, uid)]); | |
| body.push(defNode); | |
| param.replaceWith(_core.types.cloneNode(uid)); | |
| } | |
| if (transformedRestNodes) { | |
| for (const transformedNode of transformedRestNodes) { | |
| body.push(transformedNode); | |
| } | |
| } | |
| } | |
| if (firstOptionalIndex !== null) { | |
| node.params = node.params.slice(0, firstOptionalIndex); | |
| } | |
| path.ensureBlock(); | |
| const path2 = path; | |
| const { | |
| async, | |
| generator | |
| } = node; | |
| if (generator || state.needsOuterBinding || shadowedParams.size > 0) { | |
| body.push((0, _shadowUtils.buildScopeIIFE)(shadowedParams, path2.node.body)); | |
| path.set("body", _core.types.blockStatement(body)); | |
| const bodyPath = path2.get("body.body"); | |
| const arrowPath = bodyPath[bodyPath.length - 1].get("argument.callee"); | |
| arrowPath.arrowFunctionToExpression(); | |
| arrowPath.node.generator = generator; | |
| arrowPath.node.async = async; | |
| node.generator = false; | |
| node.async = false; | |
| if (async && !generator) { | |
| path2.node.body = _core.template.statement.ast`{ | |
| try { | |
| ${path2.node.body.body} | |
| } catch (e) { | |
| return Promise.reject(e); | |
| } | |
| }`; | |
| } | |
| } else { | |
| path2.get("body").unshiftContainer("body", body); | |
| } | |
| return true; | |
| } | |
| //# sourceMappingURL=params.js.map | |
Xet Storage Details
- Size:
- 5.04 kB
- Xet hash:
- c5e6b2c367cbfd2a10bb115b99631fc7bfe75697fedf39a5f589a2b8b81cbc24
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.