Server IP : 150.95.80.236 / Your IP : 3.15.25.131 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/eslint/lib/rules/ |
Upload File : |
/** * @fileoverview Rule to enforce spacing before and after keywords. * @author Toru Nagashima * @deprecated in ESLint v8.53.0 */ "use strict"; //------------------------------------------------------------------------------ // Requirements //------------------------------------------------------------------------------ const astUtils = require("./utils/ast-utils"), keywords = require("./utils/keywords"); //------------------------------------------------------------------------------ // Constants //------------------------------------------------------------------------------ const PREV_TOKEN = /^[)\]}>]$/u; const NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/u; const PREV_TOKEN_M = /^[)\]}>*]$/u; const NEXT_TOKEN_M = /^[{*]$/u; const TEMPLATE_OPEN_PAREN = /\$\{$/u; const TEMPLATE_CLOSE_PAREN = /^\}/u; const CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template|PrivateIdentifier)$/u; const KEYS = keywords.concat(["as", "async", "await", "from", "get", "let", "of", "set", "yield"]); // check duplications. (function() { KEYS.sort(); for (let i = 1; i < KEYS.length; ++i) { if (KEYS[i] === KEYS[i - 1]) { throw new Error(`Duplication was found in the keyword list: ${KEYS[i]}`); } } }()); //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ /** * Checks whether or not a given token is a "Template" token ends with "${". * @param {Token} token A token to check. * @returns {boolean} `true` if the token is a "Template" token ends with "${". */ function isOpenParenOfTemplate(token) { return token.type === "Template" && TEMPLATE_OPEN_PAREN.test(token.value); } /** * Checks whether or not a given token is a "Template" token starts with "}". * @param {Token} token A token to check. * @returns {boolean} `true` if the token is a "Template" token starts with "}". */ function isCloseParenOfTemplate(token) { return token.type === "Template" && TEMPLATE_CLOSE_PAREN.test(token.value); } //------------------------------------------------------------------------------ // Rule Definition //------------------------------------------------------------------------------ /** @type {import('../shared/types').Rule} */ module.exports = { meta: { deprecated: true, replacedBy: [], type: "layout", docs: { description: "Enforce consistent spacing before and after keywords", recommended: false, url: "https://eslint.org/docs/latest/rules/keyword-spacing" }, fixable: "whitespace", schema: [ { type: "object", properties: { before: { type: "boolean", default: true }, after: { type: "boolean", default: true }, overrides: { type: "object", properties: KEYS.reduce((retv, key) => { retv[key] = { type: "object", properties: { before: { type: "boolean" }, after: { type: "boolean" } }, additionalProperties: false }; return retv; }, {}), additionalProperties: false } }, additionalProperties: false } ], messages: { expectedBefore: "Expected space(s) before \"{{value}}\".", expectedAfter: "Expected space(s) after \"{{value}}\".", unexpectedBefore: "Unexpected space(s) before \"{{value}}\".", unexpectedAfter: "Unexpected space(s) after \"{{value}}\"." } }, create(context) { const sourceCode = context.sourceCode; const tokensToIgnore = new WeakSet(); /** * Reports a given token if there are not space(s) before the token. * @param {Token} token A token to report. * @param {RegExp} pattern A pattern of the previous token to check. * @returns {void} */ function expectSpaceBefore(token, pattern) { const prevToken = sourceCode.getTokenBefore(token); if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && astUtils.isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetweenTokens(prevToken, token) ) { context.report({ loc: token.loc, messageId: "expectedBefore", data: token, fix(fixer) { return fixer.insertTextBefore(token, " "); } }); } } /** * Reports a given token if there are space(s) before the token. * @param {Token} token A token to report. * @param {RegExp} pattern A pattern of the previous token to check. * @returns {void} */ function unexpectSpaceBefore(token, pattern) { const prevToken = sourceCode.getTokenBefore(token); if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && astUtils.isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetweenTokens(prevToken, token) ) { context.report({ loc: { start: prevToken.loc.end, end: token.loc.start }, messageId: "unexpectedBefore", data: token, fix(fixer) { return fixer.removeRange([prevToken.range[1], token.range[0]]); } }); } } /** * Reports a given token if there are not space(s) after the token. * @param {Token} token A token to report. * @param {RegExp} pattern A pattern of the next token to check. * @returns {void} */ function expectSpaceAfter(token, pattern) { const nextToken = sourceCode.getTokenAfter(token); if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && astUtils.isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetweenTokens(token, nextToken) ) { context.report({ loc: token.loc, messageId: "expectedAfter", data: token, fix(fixer) { return fixer.insertTextAfter(token, " "); } }); } } /** * Reports a given token if there are space(s) after the token. * @param {Token} token A token to report. * @param {RegExp} pattern A pattern of the next token to check. * @returns {void} */ function unexpectSpaceAfter(token, pattern) { const nextToken = sourceCode.getTokenAfter(token); if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && astUtils.isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetweenTokens(token, nextToken) ) { context.report({ loc: { start: token.loc.end, end: nextToken.loc.start }, messageId: "unexpectedAfter", data: token, fix(fixer) { return fixer.removeRange([token.range[1], nextToken.range[0]]); } }); } } /** * Parses the option object and determines check methods for each keyword. * @param {Object|undefined} options The option object to parse. * @returns {Object} - Normalized option object. * Keys are keywords (there are for every keyword). * Values are instances of `{"before": function, "after": function}`. */ function parseOptions(options = {}) { const before = options.before !== false; const after = options.after !== false; const defaultValue = { before: before ? expectSpaceBefore : unexpectSpaceBefore, after: after ? expectSpaceAfter : unexpectSpaceAfter }; const overrides = (options && options.overrides) || {}; const retv = Object.create(null); for (let i = 0; i < KEYS.length; ++i) { const key = KEYS[i]; const override = overrides[key]; if (override) { const thisBefore = ("before" in override) ? override.before : before; const thisAfter = ("after" in override) ? override.after : after; retv[key] = { before: thisBefore ? expectSpaceBefore : unexpectSpaceBefore, after: thisAfter ? expectSpaceAfter : unexpectSpaceAfter }; } else { retv[key] = defaultValue; } } return retv; } const checkMethodMap = parseOptions(context.options[0]); /** * Reports a given token if usage of spacing followed by the token is * invalid. * @param {Token} token A token to report. * @param {RegExp} [pattern] Optional. A pattern of the previous * token to check. * @returns {void} */ function checkSpacingBefore(token, pattern) { checkMethodMap[token.value].before(token, pattern || PREV_TOKEN); } /** * Reports a given token if usage of spacing preceded by the token is * invalid. * @param {Token} token A token to report. * @param {RegExp} [pattern] Optional. A pattern of the next * token to check. * @returns {void} */ function checkSpacingAfter(token, pattern) { checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN); } /** * Reports a given token if usage of spacing around the token is invalid. * @param {Token} token A token to report. * @returns {void} */ function checkSpacingAround(token) { checkSpacingBefore(token); checkSpacingAfter(token); } /** * Reports the first token of a given node if the first token is a keyword * and usage of spacing around the token is invalid. * @param {ASTNode|null} node A node to report. * @returns {void} */ function checkSpacingAroundFirstToken(node) { const firstToken = node && sourceCode.getFirstToken(node); if (firstToken && firstToken.type === "Keyword") { checkSpacingAround(firstToken); } } /** * Reports the first token of a given node if the first token is a keyword * and usage of spacing followed by the token is invalid. * * This is used for unary operators (e.g. `typeof`), `function`, and `super`. * Other rules are handling usage of spacing preceded by those keywords. * @param {ASTNode|null} node A node to report. * @returns {void} */ function checkSpacingBeforeFirstToken(node) { const firstToken = node && sourceCode.getFirstToken(node); if (firstToken && firstToken.type === "Keyword") { checkSpacingBefore(firstToken); } } /** * Reports the previous token of a given node if the token is a keyword and * usage of spacing around the token is invalid. * @param {ASTNode|null} node A node to report. * @returns {void} */ function checkSpacingAroundTokenBefore(node) { if (node) { const token = sourceCode.getTokenBefore(node, astUtils.isKeywordToken); checkSpacingAround(token); } } /** * Reports `async` or `function` keywords of a given node if usage of * spacing around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForFunction(node) { const firstToken = node && sourceCode.getFirstToken(node); if (firstToken && ((firstToken.type === "Keyword" && firstToken.value === "function") || firstToken.value === "async") ) { checkSpacingBefore(firstToken); } } /** * Reports `class` and `extends` keywords of a given node if usage of * spacing around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForClass(node) { checkSpacingAroundFirstToken(node); checkSpacingAroundTokenBefore(node.superClass); } /** * Reports `if` and `else` keywords of a given node if usage of spacing * around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForIfStatement(node) { checkSpacingAroundFirstToken(node); checkSpacingAroundTokenBefore(node.alternate); } /** * Reports `try`, `catch`, and `finally` keywords of a given node if usage * of spacing around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForTryStatement(node) { checkSpacingAroundFirstToken(node); checkSpacingAroundFirstToken(node.handler); checkSpacingAroundTokenBefore(node.finalizer); } /** * Reports `do` and `while` keywords of a given node if usage of spacing * around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForDoWhileStatement(node) { checkSpacingAroundFirstToken(node); checkSpacingAroundTokenBefore(node.test); } /** * Reports `for` and `in` keywords of a given node if usage of spacing * around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForForInStatement(node) { checkSpacingAroundFirstToken(node); const inToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken); const previousToken = sourceCode.getTokenBefore(inToken); if (previousToken.type !== "PrivateIdentifier") { checkSpacingBefore(inToken); } checkSpacingAfter(inToken); } /** * Reports `for` and `of` keywords of a given node if usage of spacing * around those keywords is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForForOfStatement(node) { if (node.await) { checkSpacingBefore(sourceCode.getFirstToken(node, 0)); checkSpacingAfter(sourceCode.getFirstToken(node, 1)); } else { checkSpacingAroundFirstToken(node); } const ofToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken); const previousToken = sourceCode.getTokenBefore(ofToken); if (previousToken.type !== "PrivateIdentifier") { checkSpacingBefore(ofToken); } checkSpacingAfter(ofToken); } /** * Reports `import`, `export`, `as`, and `from` keywords of a given node if * usage of spacing around those keywords is invalid. * * This rule handles the `*` token in module declarations. * * import*as A from "./a"; /*error Expected space(s) after "import". * error Expected space(s) before "as". * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForModuleDeclaration(node) { const firstToken = sourceCode.getFirstToken(node); checkSpacingBefore(firstToken, PREV_TOKEN_M); checkSpacingAfter(firstToken, NEXT_TOKEN_M); if (node.type === "ExportDefaultDeclaration") { checkSpacingAround(sourceCode.getTokenAfter(firstToken)); } if (node.type === "ExportAllDeclaration" && node.exported) { const asToken = sourceCode.getTokenBefore(node.exported); checkSpacingBefore(asToken, PREV_TOKEN_M); checkSpacingAfter(asToken, NEXT_TOKEN_M); } if (node.source) { const fromToken = sourceCode.getTokenBefore(node.source); checkSpacingBefore(fromToken, PREV_TOKEN_M); checkSpacingAfter(fromToken, NEXT_TOKEN_M); } } /** * Reports `as` keyword of a given node if usage of spacing around this * keyword is invalid. * @param {ASTNode} node An `ImportSpecifier` node to check. * @returns {void} */ function checkSpacingForImportSpecifier(node) { if (node.imported.range[0] !== node.local.range[0]) { const asToken = sourceCode.getTokenBefore(node.local); checkSpacingBefore(asToken, PREV_TOKEN_M); } } /** * Reports `as` keyword of a given node if usage of spacing around this * keyword is invalid. * @param {ASTNode} node An `ExportSpecifier` node to check. * @returns {void} */ function checkSpacingForExportSpecifier(node) { if (node.local.range[0] !== node.exported.range[0]) { const asToken = sourceCode.getTokenBefore(node.exported); checkSpacingBefore(asToken, PREV_TOKEN_M); checkSpacingAfter(asToken, NEXT_TOKEN_M); } } /** * Reports `as` keyword of a given node if usage of spacing around this * keyword is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForImportNamespaceSpecifier(node) { const asToken = sourceCode.getFirstToken(node, 1); checkSpacingBefore(asToken, PREV_TOKEN_M); } /** * Reports `static`, `get`, and `set` keywords of a given node if usage of * spacing around those keywords is invalid. * @param {ASTNode} node A node to report. * @throws {Error} If unable to find token get, set, or async beside method name. * @returns {void} */ function checkSpacingForProperty(node) { if (node.static) { checkSpacingAroundFirstToken(node); } if (node.kind === "get" || node.kind === "set" || ( (node.method || node.type === "MethodDefinition") && node.value.async ) ) { const token = sourceCode.getTokenBefore( node.key, tok => { switch (tok.value) { case "get": case "set": case "async": return true; default: return false; } } ); if (!token) { throw new Error("Failed to find token get, set, or async beside method name"); } checkSpacingAround(token); } } /** * Reports `await` keyword of a given node if usage of spacing before * this keyword is invalid. * @param {ASTNode} node A node to report. * @returns {void} */ function checkSpacingForAwaitExpression(node) { checkSpacingBefore(sourceCode.getFirstToken(node)); } return { // Statements DebuggerStatement: checkSpacingAroundFirstToken, WithStatement: checkSpacingAroundFirstToken, // Statements - Control flow BreakStatement: checkSpacingAroundFirstToken, ContinueStatement: checkSpacingAroundFirstToken, ReturnStatement: checkSpacingAroundFirstToken, ThrowStatement: checkSpacingAroundFirstToken, TryStatement: checkSpacingForTryStatement, // Statements - Choice IfStatement: checkSpacingForIfStatement, SwitchStatement: checkSpacingAroundFirstToken, SwitchCase: checkSpacingAroundFirstToken, // Statements - Loops DoWhileStatement: checkSpacingForDoWhileStatement, ForInStatement: checkSpacingForForInStatement, ForOfStatement: checkSpacingForForOfStatement, ForStatement: checkSpacingAroundFirstToken, WhileStatement: checkSpacingAroundFirstToken, // Statements - Declarations ClassDeclaration: checkSpacingForClass, ExportNamedDeclaration: checkSpacingForModuleDeclaration, ExportDefaultDeclaration: checkSpacingForModuleDeclaration, ExportAllDeclaration: checkSpacingForModuleDeclaration, FunctionDeclaration: checkSpacingForFunction, ImportDeclaration: checkSpacingForModuleDeclaration, VariableDeclaration: checkSpacingAroundFirstToken, // Expressions ArrowFunctionExpression: checkSpacingForFunction, AwaitExpression: checkSpacingForAwaitExpression, ClassExpression: checkSpacingForClass, FunctionExpression: checkSpacingForFunction, NewExpression: checkSpacingBeforeFirstToken, Super: checkSpacingBeforeFirstToken, ThisExpression: checkSpacingBeforeFirstToken, UnaryExpression: checkSpacingBeforeFirstToken, YieldExpression: checkSpacingBeforeFirstToken, // Others ImportSpecifier: checkSpacingForImportSpecifier, ExportSpecifier: checkSpacingForExportSpecifier, ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier, MethodDefinition: checkSpacingForProperty, PropertyDefinition: checkSpacingForProperty, StaticBlock: checkSpacingAroundFirstToken, Property: checkSpacingForProperty, // To avoid conflicts with `space-infix-ops`, e.g. `a > this.b` "BinaryExpression[operator='>']"(node) { const operatorToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken); tokensToIgnore.add(operatorToken); } }; } };