diff options
Diffstat (limited to 'node_modules/@babel/template/lib/parse.js')
| -rw-r--r-- | node_modules/@babel/template/lib/parse.js | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/node_modules/@babel/template/lib/parse.js b/node_modules/@babel/template/lib/parse.js new file mode 100644 index 0000000..0d42ed4 --- /dev/null +++ b/node_modules/@babel/template/lib/parse.js @@ -0,0 +1,188 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = parseAndBuildMetadata; + +var _t = require("@babel/types"); + +var _parser = require("@babel/parser"); + +var _codeFrame = require("@babel/code-frame"); + +const { + isCallExpression, + isExpressionStatement, + isFunction, + isIdentifier, + isJSXIdentifier, + isNewExpression, + isPlaceholder, + isStatement, + isStringLiteral, + removePropertiesDeep, + traverse +} = _t; +const PATTERN = /^[_$A-Z0-9]+$/; + +function parseAndBuildMetadata(formatter, code, opts) { + const { + placeholderWhitelist, + placeholderPattern, + preserveComments, + syntacticPlaceholders + } = opts; + const ast = parseWithCodeFrame(code, opts.parser, syntacticPlaceholders); + removePropertiesDeep(ast, { + preserveComments + }); + formatter.validate(ast); + const syntactic = { + placeholders: [], + placeholderNames: new Set() + }; + const legacy = { + placeholders: [], + placeholderNames: new Set() + }; + const isLegacyRef = { + value: undefined + }; + traverse(ast, placeholderVisitorHandler, { + syntactic, + legacy, + isLegacyRef, + placeholderWhitelist, + placeholderPattern, + syntacticPlaceholders + }); + return Object.assign({ + ast + }, isLegacyRef.value ? legacy : syntactic); +} + +function placeholderVisitorHandler(node, ancestors, state) { + var _state$placeholderWhi; + + let name; + + if (isPlaceholder(node)) { + if (state.syntacticPlaceholders === false) { + throw new Error("%%foo%%-style placeholders can't be used when " + "'.syntacticPlaceholders' is false."); + } else { + name = node.name.name; + state.isLegacyRef.value = false; + } + } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) { + return; + } else if (isIdentifier(node) || isJSXIdentifier(node)) { + name = node.name; + state.isLegacyRef.value = true; + } else if (isStringLiteral(node)) { + name = node.value; + state.isLegacyRef.value = true; + } else { + return; + } + + if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) { + throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'"); + } + + if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name))) { + return; + } + + ancestors = ancestors.slice(); + const { + node: parent, + key + } = ancestors[ancestors.length - 1]; + let type; + + if (isStringLiteral(node) || isPlaceholder(node, { + expectedNode: "StringLiteral" + })) { + type = "string"; + } else if (isNewExpression(parent) && key === "arguments" || isCallExpression(parent) && key === "arguments" || isFunction(parent) && key === "params") { + type = "param"; + } else if (isExpressionStatement(parent) && !isPlaceholder(node)) { + type = "statement"; + ancestors = ancestors.slice(0, -1); + } else if (isStatement(node) && isPlaceholder(node)) { + type = "statement"; + } else { + type = "other"; + } + + const { + placeholders, + placeholderNames + } = state.isLegacyRef.value ? state.legacy : state.syntactic; + placeholders.push({ + name, + type, + resolve: ast => resolveAncestors(ast, ancestors), + isDuplicate: placeholderNames.has(name) + }); + placeholderNames.add(name); +} + +function resolveAncestors(ast, ancestors) { + let parent = ast; + + for (let i = 0; i < ancestors.length - 1; i++) { + const { + key, + index + } = ancestors[i]; + + if (index === undefined) { + parent = parent[key]; + } else { + parent = parent[key][index]; + } + } + + const { + key, + index + } = ancestors[ancestors.length - 1]; + return { + parent, + key, + index + }; +} + +function parseWithCodeFrame(code, parserOpts, syntacticPlaceholders) { + const plugins = (parserOpts.plugins || []).slice(); + + if (syntacticPlaceholders !== false) { + plugins.push("placeholders"); + } + + parserOpts = Object.assign({ + allowReturnOutsideFunction: true, + allowSuperOutsideMethod: true, + sourceType: "module" + }, parserOpts, { + plugins + }); + + try { + return (0, _parser.parse)(code, parserOpts); + } catch (err) { + const loc = err.loc; + + if (loc) { + err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code, { + start: loc + }); + err.code = "BABEL_TEMPLATE_PARSE_ERROR"; + } + + throw err; + } +}
\ No newline at end of file |