| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = void 0; |
| |
| function _helperPluginUtils() { |
| const data = require("@babel/helper-plugin-utils"); |
| |
| _helperPluginUtils = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| function _helperModuleTransforms() { |
| const data = require("@babel/helper-module-transforms"); |
| |
| _helperModuleTransforms = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| function _core() { |
| const data = require("@babel/core"); |
| |
| _core = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| function _utils() { |
| const data = require("babel-plugin-dynamic-import-node/utils"); |
| |
| _utils = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| const buildWrapper = (0, _core().template)(` |
| define(MODULE_NAME, AMD_ARGUMENTS, function(IMPORT_NAMES) { |
| }) |
| `); |
| const buildAnonymousWrapper = (0, _core().template)(` |
| define(["require"], function(REQUIRE) { |
| }) |
| `); |
| |
| function injectWrapper(path, wrapper) { |
| const { |
| body, |
| directives |
| } = path.node; |
| path.node.directives = []; |
| path.node.body = []; |
| const amdWrapper = path.pushContainer("body", wrapper)[0]; |
| const amdFactory = amdWrapper.get("expression.arguments").filter(arg => arg.isFunctionExpression())[0].get("body"); |
| amdFactory.pushContainer("directives", directives); |
| amdFactory.pushContainer("body", body); |
| } |
| |
| var _default = (0, _helperPluginUtils().declare)((api, options) => { |
| api.assertVersion(7); |
| const { |
| loose, |
| allowTopLevelThis, |
| strict, |
| strictMode, |
| noInterop |
| } = options; |
| return { |
| name: "transform-modules-amd", |
| |
| pre() { |
| this.file.set("@babel/plugin-transform-modules-*", "amd"); |
| }, |
| |
| visitor: { |
| CallExpression(path, state) { |
| if (!this.file.has("@babel/plugin-proposal-dynamic-import")) return; |
| if (!path.get("callee").isImport()) return; |
| let { |
| requireId, |
| resolveId, |
| rejectId |
| } = state; |
| |
| if (!requireId) { |
| requireId = path.scope.generateUidIdentifier("require"); |
| state.requireId = requireId; |
| } |
| |
| if (!resolveId || !rejectId) { |
| resolveId = path.scope.generateUidIdentifier("resolve"); |
| rejectId = path.scope.generateUidIdentifier("reject"); |
| state.resolveId = resolveId; |
| state.rejectId = rejectId; |
| } |
| |
| let result = _core().types.identifier("imported"); |
| |
| if (!noInterop) result = (0, _helperModuleTransforms().wrapInterop)(path, result, "namespace"); |
| path.replaceWith(_core().template.expression.ast` |
| new Promise((${resolveId}, ${rejectId}) => |
| ${requireId}( |
| [${(0, _utils().getImportSource)(_core().types, path.node)}], |
| imported => ${resolveId}(${result}), |
| ${rejectId} |
| ) |
| )`); |
| }, |
| |
| Program: { |
| exit(path, { |
| requireId |
| }) { |
| if (!(0, _helperModuleTransforms().isModule)(path)) { |
| if (requireId) { |
| injectWrapper(path, buildAnonymousWrapper({ |
| REQUIRE: requireId |
| })); |
| } |
| |
| return; |
| } |
| |
| const amdArgs = []; |
| const importNames = []; |
| |
| if (requireId) { |
| amdArgs.push(_core().types.stringLiteral("require")); |
| importNames.push(requireId); |
| } |
| |
| let moduleName = this.getModuleName(); |
| if (moduleName) moduleName = _core().types.stringLiteral(moduleName); |
| const { |
| meta, |
| headers |
| } = (0, _helperModuleTransforms().rewriteModuleStatementsAndPrepareHeader)(path, { |
| loose, |
| strict, |
| strictMode, |
| allowTopLevelThis, |
| noInterop |
| }); |
| |
| if ((0, _helperModuleTransforms().hasExports)(meta)) { |
| amdArgs.push(_core().types.stringLiteral("exports")); |
| importNames.push(_core().types.identifier(meta.exportName)); |
| } |
| |
| for (const [source, metadata] of meta.source) { |
| amdArgs.push(_core().types.stringLiteral(source)); |
| importNames.push(_core().types.identifier(metadata.name)); |
| |
| if (!(0, _helperModuleTransforms().isSideEffectImport)(metadata)) { |
| const interop = (0, _helperModuleTransforms().wrapInterop)(path, _core().types.identifier(metadata.name), metadata.interop); |
| |
| if (interop) { |
| const header = _core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.identifier(metadata.name), interop)); |
| |
| header.loc = metadata.loc; |
| headers.push(header); |
| } |
| } |
| |
| headers.push(...(0, _helperModuleTransforms().buildNamespaceInitStatements)(meta, metadata, loose)); |
| } |
| |
| (0, _helperModuleTransforms().ensureStatementsHoisted)(headers); |
| path.unshiftContainer("body", headers); |
| injectWrapper(path, buildWrapper({ |
| MODULE_NAME: moduleName, |
| AMD_ARGUMENTS: _core().types.arrayExpression(amdArgs), |
| IMPORT_NAMES: importNames |
| })); |
| } |
| |
| } |
| } |
| }; |
| }); |
| |
| exports.default = _default; |