source: frontend/node_modules/@babel/helper-module-transforms/lib/index.js

Last change on this file was 9af201e, checked in by MBK <marija.karapandzova@…>, 12 days ago

Fix frontend appearance
  • Property mode set to 100644
File size: 13.2 KB
Line 
1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4 value: true
5});
6Object.defineProperty(exports, "buildDynamicImport", {
7 enumerable: true,
8 get: function () {
9 return _dynamicImport.buildDynamicImport;
10 }
11});
12exports.buildNamespaceInitStatements = buildNamespaceInitStatements;
13exports.ensureStatementsHoisted = ensureStatementsHoisted;
14Object.defineProperty(exports, "getModuleName", {
15 enumerable: true,
16 get: function () {
17 return _getModuleName.default;
18 }
19});
20Object.defineProperty(exports, "hasExports", {
21 enumerable: true,
22 get: function () {
23 return _normalizeAndLoadMetadata.hasExports;
24 }
25});
26Object.defineProperty(exports, "isModule", {
27 enumerable: true,
28 get: function () {
29 return _helperModuleImports.isModule;
30 }
31});
32Object.defineProperty(exports, "isSideEffectImport", {
33 enumerable: true,
34 get: function () {
35 return _normalizeAndLoadMetadata.isSideEffectImport;
36 }
37});
38exports.rewriteModuleStatementsAndPrepareHeader = rewriteModuleStatementsAndPrepareHeader;
39Object.defineProperty(exports, "rewriteThis", {
40 enumerable: true,
41 get: function () {
42 return _rewriteThis.default;
43 }
44});
45exports.wrapInterop = wrapInterop;
46var _assert = require("assert");
47var _core = require("@babel/core");
48var _helperModuleImports = require("@babel/helper-module-imports");
49var _rewriteThis = require("./rewrite-this.js");
50var _rewriteLiveReferences = require("./rewrite-live-references.js");
51var _normalizeAndLoadMetadata = require("./normalize-and-load-metadata.js");
52var Lazy = require("./lazy-modules.js");
53var _dynamicImport = require("./dynamic-import.js");
54var _getModuleName = require("./get-module-name.js");
55exports.getDynamicImportSource = require("./dynamic-import").getDynamicImportSource;
56function rewriteModuleStatementsAndPrepareHeader(path, {
57 exportName,
58 strict,
59 allowTopLevelThis,
60 strictMode,
61 noInterop,
62 importInterop = noInterop ? "none" : "babel",
63 lazy,
64 getWrapperPayload = Lazy.toGetWrapperPayload(lazy != null ? lazy : false),
65 wrapReference = Lazy.wrapReference,
66 esNamespaceOnly,
67 filename,
68 constantReexports = arguments[1].loose,
69 enumerableModuleMeta = arguments[1].loose,
70 noIncompleteNsImportDetection
71}) {
72 (0, _normalizeAndLoadMetadata.validateImportInteropOption)(importInterop);
73 _assert((0, _helperModuleImports.isModule)(path), "Cannot process module statements in a script");
74 path.node.sourceType = "script";
75 const meta = (0, _normalizeAndLoadMetadata.default)(path, exportName, {
76 importInterop,
77 initializeReexports: constantReexports,
78 getWrapperPayload,
79 esNamespaceOnly,
80 filename
81 });
82 if (!allowTopLevelThis) {
83 (0, _rewriteThis.default)(path);
84 }
85 (0, _rewriteLiveReferences.default)(path, meta, wrapReference);
86 if (strictMode !== false) {
87 const hasStrict = path.node.directives.some(directive => {
88 return directive.value.value === "use strict";
89 });
90 if (!hasStrict) {
91 path.unshiftContainer("directives", _core.types.directive(_core.types.directiveLiteral("use strict")));
92 }
93 }
94 const headers = [];
95 if ((0, _normalizeAndLoadMetadata.hasExports)(meta) && !strict) {
96 headers.push(buildESModuleHeader(meta, enumerableModuleMeta));
97 }
98 const nameList = buildExportNameListDeclaration(path, meta);
99 if (nameList) {
100 meta.exportNameListName = nameList.name;
101 headers.push(nameList.statement);
102 }
103 headers.push(...buildExportInitializationStatements(path, meta, wrapReference, constantReexports, noIncompleteNsImportDetection));
104 return {
105 meta,
106 headers
107 };
108}
109function ensureStatementsHoisted(statements) {
110 statements.forEach(header => {
111 header._blockHoist = 3;
112 });
113}
114function wrapInterop(programPath, expr, type) {
115 if (type === "none") {
116 return null;
117 }
118 if (type === "node-namespace") {
119 return _core.types.callExpression(programPath.hub.addHelper("interopRequireWildcard"), [expr, _core.types.booleanLiteral(true)]);
120 } else if (type === "node-default") {
121 return null;
122 }
123 let helper;
124 if (type === "default") {
125 helper = "interopRequireDefault";
126 } else if (type === "namespace") {
127 helper = "interopRequireWildcard";
128 } else {
129 throw new Error(`Unknown interop: ${type}`);
130 }
131 return _core.types.callExpression(programPath.hub.addHelper(helper), [expr]);
132}
133function buildNamespaceInitStatements(metadata, sourceMetadata, constantReexports = false, wrapReference = Lazy.wrapReference) {
134 var _wrapReference;
135 const statements = [];
136 const srcNamespaceId = _core.types.identifier(sourceMetadata.name);
137 for (const localName of sourceMetadata.importsNamespace) {
138 if (localName === sourceMetadata.name) continue;
139 statements.push(_core.template.statement`var NAME = SOURCE;`({
140 NAME: localName,
141 SOURCE: _core.types.cloneNode(srcNamespaceId)
142 }));
143 }
144 const srcNamespace = (_wrapReference = wrapReference(srcNamespaceId, sourceMetadata.wrap)) != null ? _wrapReference : srcNamespaceId;
145 if (constantReexports) {
146 statements.push(...buildReexportsFromMeta(metadata, sourceMetadata, true, wrapReference));
147 }
148 for (const exportName of sourceMetadata.reexportNamespace) {
149 statements.push((!_core.types.isIdentifier(srcNamespace) ? _core.template.statement`
150 Object.defineProperty(EXPORTS, "NAME", {
151 enumerable: true,
152 get: function() {
153 return NAMESPACE;
154 }
155 });
156 ` : _core.template.statement`EXPORTS.NAME = NAMESPACE;`)({
157 EXPORTS: metadata.exportName,
158 NAME: exportName,
159 NAMESPACE: _core.types.cloneNode(srcNamespace)
160 }));
161 }
162 if (sourceMetadata.reexportAll) {
163 const statement = buildNamespaceReexport(metadata, _core.types.cloneNode(srcNamespace), constantReexports);
164 statement.loc = sourceMetadata.reexportAll.loc;
165 statements.push(statement);
166 }
167 return statements;
168}
169const ReexportTemplate = {
170 constant: ({
171 exports,
172 exportName,
173 namespaceImport
174 }) => _core.template.statement.ast`
175 ${exports}.${exportName} = ${namespaceImport};
176 `,
177 constantComputed: ({
178 exports,
179 exportName,
180 namespaceImport
181 }) => _core.template.statement.ast`
182 ${exports}["${exportName}"] = ${namespaceImport};
183 `,
184 spec: ({
185 exports,
186 exportName,
187 namespaceImport
188 }) => _core.template.statement.ast`
189 Object.defineProperty(${exports}, "${exportName}", {
190 enumerable: true,
191 get: function() {
192 return ${namespaceImport};
193 },
194 });
195 `
196};
197function buildReexportsFromMeta(meta, metadata, constantReexports, wrapReference) {
198 var _wrapReference2;
199 let namespace = _core.types.identifier(metadata.name);
200 namespace = (_wrapReference2 = wrapReference(namespace, metadata.wrap)) != null ? _wrapReference2 : namespace;
201 const {
202 stringSpecifiers
203 } = meta;
204 return Array.from(metadata.reexports, ([exportName, importName]) => {
205 let namespaceImport = _core.types.cloneNode(namespace);
206 if (importName === "default" && metadata.interop === "node-default") {} else if (stringSpecifiers.has(importName)) {
207 namespaceImport = _core.types.memberExpression(namespaceImport, _core.types.stringLiteral(importName), true);
208 } else {
209 namespaceImport = _core.types.memberExpression(namespaceImport, _core.types.identifier(importName));
210 }
211 const astNodes = {
212 exports: meta.exportName,
213 exportName,
214 namespaceImport
215 };
216 if (constantReexports || _core.types.isIdentifier(namespaceImport)) {
217 if (stringSpecifiers.has(exportName)) {
218 return ReexportTemplate.constantComputed(astNodes);
219 } else {
220 return ReexportTemplate.constant(astNodes);
221 }
222 } else {
223 return ReexportTemplate.spec(astNodes);
224 }
225 });
226}
227function buildESModuleHeader(metadata, enumerableModuleMeta = false) {
228 return (enumerableModuleMeta ? _core.template.statement`
229 EXPORTS.__esModule = true;
230 ` : _core.template.statement`
231 Object.defineProperty(EXPORTS, "__esModule", {
232 value: true,
233 });
234 `)({
235 EXPORTS: metadata.exportName
236 });
237}
238function buildNamespaceReexport(metadata, namespace, constantReexports) {
239 return (constantReexports ? _core.template.statement`
240 Object.keys(NAMESPACE).forEach(function(key) {
241 if (key === "default" || key === "__esModule") return;
242 VERIFY_NAME_LIST;
243 if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;
244
245 EXPORTS[key] = NAMESPACE[key];
246 });
247 ` : _core.template.statement`
248 Object.keys(NAMESPACE).forEach(function(key) {
249 if (key === "default" || key === "__esModule") return;
250 VERIFY_NAME_LIST;
251 if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;
252
253 Object.defineProperty(EXPORTS, key, {
254 enumerable: true,
255 get: function() {
256 return NAMESPACE[key];
257 },
258 });
259 });
260 `)({
261 NAMESPACE: namespace,
262 EXPORTS: metadata.exportName,
263 VERIFY_NAME_LIST: metadata.exportNameListName ? (0, _core.template)`
264 if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return;
265 `({
266 EXPORTS_LIST: metadata.exportNameListName
267 }) : null
268 });
269}
270function buildExportNameListDeclaration(programPath, metadata) {
271 const exportedVars = Object.create(null);
272 for (const data of metadata.local.values()) {
273 for (const name of data.names) {
274 exportedVars[name] = true;
275 }
276 }
277 let hasReexport = false;
278 for (const data of metadata.source.values()) {
279 for (const exportName of data.reexports.keys()) {
280 exportedVars[exportName] = true;
281 }
282 for (const exportName of data.reexportNamespace) {
283 exportedVars[exportName] = true;
284 }
285 hasReexport = hasReexport || !!data.reexportAll;
286 }
287 if (!hasReexport || Object.keys(exportedVars).length === 0) return null;
288 const name = programPath.scope.generateUidIdentifier("exportNames");
289 delete exportedVars.default;
290 return {
291 name: name.name,
292 statement: _core.types.variableDeclaration("var", [_core.types.variableDeclarator(name, _core.types.valueToNode(exportedVars))])
293 };
294}
295function buildExportInitializationStatements(programPath, metadata, wrapReference, constantReexports = false, noIncompleteNsImportDetection = false) {
296 const initStatements = [];
297 for (const [localName, data] of metadata.local) {
298 if (data.kind === "import") {} else if (data.kind === "hoisted") {
299 initStatements.push([data.names[0], buildInitStatement(metadata, data.names, _core.types.identifier(localName))]);
300 } else if (!noIncompleteNsImportDetection) {
301 for (const exportName of data.names) {
302 initStatements.push([exportName, null]);
303 }
304 }
305 }
306 for (const data of metadata.source.values()) {
307 if (!constantReexports) {
308 const reexportsStatements = buildReexportsFromMeta(metadata, data, false, wrapReference);
309 const reexports = [...data.reexports.keys()];
310 for (let i = 0; i < reexportsStatements.length; i++) {
311 initStatements.push([reexports[i], reexportsStatements[i]]);
312 }
313 }
314 if (!noIncompleteNsImportDetection) {
315 for (const exportName of data.reexportNamespace) {
316 initStatements.push([exportName, null]);
317 }
318 }
319 }
320 initStatements.sort(([a], [b]) => {
321 if (a < b) return -1;
322 if (b < a) return 1;
323 return 0;
324 });
325 const results = [];
326 if (noIncompleteNsImportDetection) {
327 for (const [, initStatement] of initStatements) {
328 results.push(initStatement);
329 }
330 } else {
331 const chunkSize = 100;
332 for (let i = 0; i < initStatements.length; i += chunkSize) {
333 let uninitializedExportNames = [];
334 for (let j = 0; j < chunkSize && i + j < initStatements.length; j++) {
335 const [exportName, initStatement] = initStatements[i + j];
336 if (initStatement !== null) {
337 if (uninitializedExportNames.length > 0) {
338 results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode()));
339 uninitializedExportNames = [];
340 }
341 results.push(initStatement);
342 } else {
343 uninitializedExportNames.push(exportName);
344 }
345 }
346 if (uninitializedExportNames.length > 0) {
347 results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode()));
348 }
349 }
350 }
351 return results;
352}
353const InitTemplate = {
354 computed: ({
355 exports,
356 name,
357 value
358 }) => _core.template.expression.ast`${exports}["${name}"] = ${value}`,
359 default: ({
360 exports,
361 name,
362 value
363 }) => _core.template.expression.ast`${exports}.${name} = ${value}`,
364 define: ({
365 exports,
366 name,
367 value
368 }) => _core.template.expression.ast`
369 Object.defineProperty(${exports}, "${name}", {
370 enumerable: true,
371 value: void 0,
372 writable: true
373 })["${name}"] = ${value}`
374};
375function buildInitStatement(metadata, exportNames, initExpr) {
376 const {
377 stringSpecifiers,
378 exportName: exports
379 } = metadata;
380 return _core.types.expressionStatement(exportNames.reduce((value, name) => {
381 const params = {
382 exports,
383 name,
384 value
385 };
386 if (name === "__proto__") {
387 return InitTemplate.define(params);
388 }
389 if (stringSpecifiers.has(name)) {
390 return InitTemplate.computed(params);
391 }
392 return InitTemplate.default(params);
393 }, initExpr));
394}
395
396//# sourceMappingURL=index.js.map
Note: See TracBrowser for help on using the repository browser.