eslint-plugin-crisp 1.5.13 → 1.6.0

package/.github/workflows/build.yml

@@ -26,5 +26,11 @@ jobs:
       - name: Verify versions
         run: node --version && npm --version && node -p process.versions.v8
 
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
       - name: Release package
         run: npm publish --ignore-scripts --provenance

package/README.md

@@ -133,12 +133,13 @@ Each item has emojis denoting:
 | [crisp/multiline-comment-end-backslash](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/multiline-comment-end-backslash.js) | Enforces multiline comments to end with a backslash | 🟠 | 🟢 | 🟣 |
 | [crisp/newline-after-switch-case](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/newline-after-switch-case.js) | Requires newline between switch cases | 🟠 | 🟢 | 🟣 |
 | [crisp/no-async](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-async.js) | Disallows the use of `async/syntax`, in favor of `Promise` | 🟠 | 🟢 |
-| [crisp/no-short-parameters](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-short-parameters.js) | Disallow parameter names shorter than 3 characters | 🟠 | 🟢 | 🟣 |
+| [crisp/no-short-parameters](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-short-parameters.js) | Disallows one-character parameter names | 🟠 | 🟢 | 🟣 |
 | [crisp/no-space-in-optional-arguments](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-space-in-optional-arguments.js) | Disallows space before or after `=` in optional parameters | 🟠 |
 | [crisp/no-snake-case](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-snake-case.js) | Disallows snake_case |  | 🟢 | 🟣 |
 | [crisp/no-useless-template-literals](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-useless-template-literals.js) | Disallows unnecessary use of template literals |  | 🟢 | 🟣 |
 | [crisp/no-var-in-blocks](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/no-var-in-blocks.js) | Disallows `var` declarations inside function, method, or class block | 🟠 | 🟢 | 🟣 |
 | [crisp/one-space-after-operator](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/one-space-after-operator.js) | Enforces at least one space before and one space after `=` and `:` operators | 🟠 | 🟢 | 🟣 |
+| [crisp/vue-pinia-action-single-parameter](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/vue-pinia-action-single-parameter.js) | Requires Pinia actions to accept at most one payload argument |  | 🟢 |  |
 | [crisp/regex-in-constructor](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/regex-in-constructor.js) | Ensures regular expressions are defined in the class constructor | 🟠 | 🟢 | 🟣 |
 | [crisp/ternary-parenthesis](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/ternary-parenthesis.js) | Enforces parentheses around conditions with operators in ternary expressions | 🟠 | 🟢 | 🟣 |
 | [crisp/two-lines-between-class-members](https://github.com/crisp-oss/eslint-plugin-crisp/blob/master/rules/two-lines-between-class-members.js) | Requires exactly two line breaks between class methods | 🟠 |

package/index.js

@@ -58,6 +58,7 @@ import ruleVueNoComponentClassShorthand from "./rules/vue-no-component-class-sho
 import ruleVueNoMixedClass from "./rules/vue-no-mixed-class.js";
 import ruleVueNoNameOption from "./rules/vue-no-name-option.js";
 import ruleVueNoRegexData from "./rules/vue-no-regex-data.js";
+import ruleVuePiniaActionSingleParameter from "./rules/vue-pinia-action-single-parameter.js";
 import ruleVuePropsDeclarationLineBreak from "./rules/vue-props-declaration-line-break.js";
 import ruleVuePropsDeclarationMultiline from "./rules/vue-props-declaration-multiline.js";
 import ruleVuePropsDeclarationOrder from "./rules/vue-props-declaration-order.js";
@@ -134,6 +135,7 @@ const plugin = {
     "vue-no-mixed-class": ruleVueNoMixedClass,
     "vue-no-name-option": ruleVueNoNameOption,
     "vue-no-regex-data": ruleVueNoRegexData,
+    "vue-pinia-action-single-parameter": ruleVuePiniaActionSingleParameter,
     "vue-props-declaration-line-break": ruleVuePropsDeclarationLineBreak,
     "vue-props-declaration-multiline": ruleVuePropsDeclarationMultiline,
     "vue-props-declaration-order": ruleVuePropsDeclarationOrder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.5.13",
+  "version": "1.6.0",
   "description": "Custom ESLint Rules for Crisp",
   "author": "Crisp IM SAS",
   "main": "index.js",
@@ -13,6 +13,9 @@
   "bugs": {
     "url": "https://github.com/crisp-oss/eslint-plugin-crisp/issues"
   },
+  "scripts": {
+    "test": "node --test"
+  },
   "dependencies": {
     "@eslint/js": "9.39.5",
     "doctrine": "3.0.0",
@@ -21,6 +24,11 @@
     "typescript": "5.9.3",
     "typescript-eslint": "8.72.0"
   },
+  "devDependencies": {
+    "eslint": "9.39.5",
+    "vue-eslint-parser": "10.4.1",
+    "vue-eslint-parser-template-tokenizer-pug": "1.0.0"
+  },
   "peerDependencies": {
     "eslint": "^9.39.5",
     "eslint-plugin-vue": "^10.11.1",

package/recommended-vue.js

@@ -393,6 +393,7 @@ export default function configRecommendedVue(pluginCrisp) {
         "crisp/vue-no-mixed-class": "error",
         "crisp/vue-no-name-option": "error",
         "crisp/vue-no-regex-data": "error",
+        "crisp/vue-pinia-action-single-parameter": "error",
         "crisp/vue-props-declaration-line-break": "error",
         "crisp/vue-props-declaration-multiline": "error",
         "crisp/vue-props-declaration-order": "error",

package/rules/align-comments.js

@@ -52,9 +52,12 @@ export default {
 
             fix(fixer) {
               const indent = " ".repeat(nodeIndent);
-              const commentText = sourceCode.getText(comment);
-              const fixedComment = `\n${indent}${commentText.trim()}`;
-              return fixer.replaceTextRange([comment.range[0], comment.range[1]], fixedComment);
+              const lineStart = sourceCode.getIndexFromLoc({
+                line: comment.loc.start.line,
+                column: 0
+              });
+
+              return fixer.replaceTextRange([lineStart, comment.range[0]], indent);
             },
           });
         }

package/rules/constructor-variables.js

@@ -25,7 +25,7 @@ export default {
 
   create(context) {
     const options = context.options[0] || {};
-    const filename = context.getFilename();
+    const filename = context.filename || context.getFilename();
     const filenameExceptions = options.filenameExceptions || [];
     const variableExceptions = options.variableExceptions || [];
 
@@ -34,7 +34,22 @@ export default {
     return {
       "MethodDefinition[kind='constructor'] > FunctionExpression > BlockStatement > ExpressionStatement > AssignmentExpression": function(node) {
         if(node.left.type === "MemberExpression" && node.left.object.type === "ThisExpression") {
-          const varName = node.left.property.name;
+          let varName = null;
+
+          if (!node.left.computed && node.left.property.type === "Identifier") {
+            varName = node.left.property.name;
+          } else if (
+            node.left.computed &&
+            node.left.property.type === "Literal" &&
+            typeof node.left.property.value === "string"
+          ) {
+            varName = node.left.property.value;
+          }
+
+          if (!varName) {
+            return;
+          }
+
           if (!varName.startsWith("_") && !isFilenameException && !variableExceptions.includes(varName)) {
             context.report({
               node,

package/rules/header-check.js

@@ -55,9 +55,15 @@ export default {
 
         if (headerStart && headerEnd) {
           // Construct the final headerFormat RegExps
-          const headerFormats = basePatterns.map(pattern => headerStart && headerEnd ? new RegExp("^" + headerStart + pattern + headerEnd) : null);
+          const headerFormats = basePatterns.flatMap(pattern => {
+            try {
+              return [new RegExp("^" + headerStart + pattern + headerEnd)];
+            } catch {
+              return [];
+            }
+          });
 
-          if (headerFormats.some(format => format && format.test(fileContent)) === false) {
+          if (headerFormats.some(format => format.test(fileContent)) === false) {
             context.report({
               node,
               message: "File must start with the proper header.",

package/rules/header-comments-check.js

@@ -113,7 +113,7 @@ export default {
   },
 
   create(context) {
-    const filename = context.getFilename();
+    const filename = context.filename || context.getFilename();
 
     if (!filename.endsWith(".js") && !filename.endsWith(".ts")) {
       return {};
@@ -223,7 +223,10 @@ export default {
 
         case "ExportDefaultDeclaration": {
           // Only enforce the 'EXPORTS' comment block if it's the last statement in the file
-          if (startNode !== context.getSourceCode().ast.body.slice(-1)[0] && (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("EXPORTS"))) {
+          if (
+            startNode === sourceCode.ast.body.slice(-1)[0] &&
+            (!comment || `/*${comment.value.trim()}*/` !== COMMENT_HEADER_FORMAT("EXPORTS"))
+          ) {
             context.report({
               node: startNode,
               message: "Export group must be preceded by a 'EXPORTS' comment block",
@@ -237,9 +240,17 @@ export default {
 
     return {
       ":statement": (node) => {
+        if (node.parent.type !== "Program") {
+          return;
+        }
+
         // If the type of node has changed since last time, or if we have a \
         //   regex declaration and the previous declaration wasn't one
-        if (node.type !== lastNode || isRegex(node) !== isRegex(lastNode)) {
+        if (
+          !lastNode ||
+          node.type !== lastNode.type ||
+          isRegex(node) !== isRegex(lastNode)
+        ) {
           // Check the group starting with the last node
           if (groupStart) {
             checkGroup(lastNode.type, groupStart);

package/rules/import-group-comment.js

@@ -29,9 +29,14 @@ function isIgnoreComment(comment) {
 }
 
 function getDirectoryName(filePath) {
-  const pathParts = filePath.split("/");
+  if (!filePath || filePath.startsWith("<")) {
+    return "MAIN";
+  }
+
+  const pathParts = filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  const directoryName = pathParts.at(-2);
 
-  return pathParts[pathParts.length - 2].toUpperCase();
+  return directoryName ? directoryName.toUpperCase() : "MAIN";
 }
 
 function generateExpectedComment(group) {
@@ -70,8 +75,12 @@ export default {
     const customGroups = context.options[0] || {};  // Get custom groups from options
 
     // Pre-compile custom regexes once instead of on every import
-    const compiledCustomGroups = Object.entries(customGroups).map(([regexStr, group]) => {
-      return [new RegExp(regexStr), group];
+    const compiledCustomGroups = Object.entries(customGroups).flatMap(([regexStr, group]) => {
+      try {
+        return [[new RegExp(regexStr), group]];
+      } catch {
+        return [];
+      }
     });
 
     let currentGroupComment = null;

package/rules/jsdoc-enforce-access.js

@@ -1,5 +1,5 @@
 // Pre-compiled regex for access modifier check
-const ACCESS_MODIFIER_PATTERN = /@(public|protected|private|internal)/;
+const ACCESS_MODIFIER_PATTERN = /@(public|protected|private|internal)(?=\s|\*|$)/;
 
 export default {
   meta: {
@@ -16,19 +16,25 @@ export default {
 
     function checkNodeForJSDoc(node) {
       const comments = sourceCode.getCommentsBefore(node);
+      let jsdocComment = null;
 
-      if (comments.length > 0) {
-        const lastComment = comments[comments.length - 1];
+      for (let i = comments.length - 1; i >= 0; i--) {
+        if (
+          comments[i].type === "Block" &&
+          comments[i].value.startsWith("*")
+        ) {
+          jsdocComment = comments[i];
 
-        if (lastComment.type === "Block" && lastComment.value.startsWith("*")) {
-          if (!ACCESS_MODIFIER_PATTERN.test(lastComment.value)) {
-            context.report({
-              node,
-              message: "JSDoc comment should contain @public, @protected, @private or @internal",
-            });
-          }
+          break;
         }
       }
+
+      if (jsdocComment && !ACCESS_MODIFIER_PATTERN.test(jsdocComment.value)) {
+        context.report({
+          node,
+          message: "JSDoc comment should contain @public, @protected, @private or @internal",
+        });
+      }
     }
 
     return {

package/rules/no-extra-line-within-function.js

@@ -37,11 +37,14 @@ export default {
             node: currentNode,
             message: "Expected at most one line break between declarations within a function.",
             fix(fixer) {
-              const range = [
-                sourceCode.getIndexFromLoc({ line: lineOfPreviousNodeEnd, column: 0 }),
-                sourceCode.getIndexFromLoc({ line: lineOfCurrentNode, column: 0 })
-              ];
-              return fixer.replaceTextRange(range, "\n\n");
+              const range = [previousNode.range[1], currentNode.range[0]];
+              const textBetween = sourceCode.text.slice(...range);
+              const fixedText = textBetween.replace(
+                /\n(?:[ \t]*\n){2,}/g,
+                "\n\n"
+              );
+
+              return fixer.replaceTextRange(range, fixedText);
             }
           });
         }

package/rules/no-short-parameters.js

@@ -2,7 +2,7 @@ export default {
   meta: {
     type: "suggestion",
     docs: {
-      description: "disallow short parameter names",
+      description: "disallow one-character parameter names",
       category: "Stylistic Issues",
     },
     schema: [

package/rules/no-snake-case.js

@@ -92,18 +92,6 @@ export default {
             reportSnakeCase(node, name, "Method");
           }
         }
-
-        // Check method parameters
-        if (node.value && node.value.params) {
-          node.value.params.forEach((param) => {
-            if (param.type === "Identifier" && param.name) {
-              const name = param.name;
-              if (isSnakeCase(name)) {
-                reportSnakeCase(param, name, "Parameter");
-              }
-            }
-          });
-        }
       },
 
       // Check function expressions
@@ -142,18 +130,6 @@ export default {
               reportSnakeCase(node, name, "Method");
             }
           }
-
-          // Check method parameters
-          if (node.value && node.value.params) {
-            node.value.params.forEach((param) => {
-              if (param.type === "Identifier" && param.name) {
-                const name = param.name;
-                if (isSnakeCase(name)) {
-                  reportSnakeCase(param, name, "Parameter");
-                }
-              }
-            });
-          }
         }
       }
     };

package/rules/no-space-in-optional-arguments.js

@@ -4,10 +4,13 @@ export default {
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression, MethodDefinition": function(node) {
         (node.params || []).forEach(param => {
           if (param.type === "AssignmentPattern") {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode || context.getSourceCode();
             const operatorToken = sourceCode.getFirstTokenBetween(param.left, param.right, token => token.value === "=");
 
-            if (sourceCode.getTokenBefore(operatorToken).end !== operatorToken.start || sourceCode.getTokenAfter(operatorToken).start !== operatorToken.end) {
+            if (
+              sourceCode.getTokenBefore(operatorToken).range[1] !== operatorToken.range[0] ||
+              sourceCode.getTokenAfter(operatorToken).range[0] !== operatorToken.range[1]
+            ) {
               context.report({
                 node,
                 message: "There should be no space before or after = in optional parameters"

package/rules/one-space-after-operator.js

@@ -27,17 +27,47 @@ export default {
     const config = context.options[0] || {};
     const checkColon = config.checkColon !== false;
 
-    const checkSpacing = (node, operatorToken, operatorName) => {
-      if (Math.abs(sourceCode.getTokenBefore(operatorToken).loc.end.column - operatorToken.loc.start.column) < 1 || sourceCode.getTokenAfter(operatorToken).loc.start.column - operatorToken.loc.end.column > 1) {
+    const checkSpacing = (operatorToken) => {
+      if (!operatorToken) {
+        return;
+      }
+
+      const tokenBefore = sourceCode.getTokenBefore(operatorToken);
+      const tokenAfter = sourceCode.getTokenAfter(operatorToken);
+      const beforeText = sourceCode.text.slice(
+        tokenBefore.range[1],
+        operatorToken.range[0]
+      );
+      const afterText = sourceCode.text.slice(
+        operatorToken.range[1],
+        tokenAfter.range[0]
+      );
+      const hasSpaceBefore = /[ \t]$/.test(beforeText);
+      const hasOneSpaceAfter = afterText === " ";
+
+      if (!hasSpaceBefore || !hasOneSpaceAfter) {
         context.report({
           node: operatorToken,
-          message: `There should be at least one space before and exactly one space after '${operatorName}'`,
+          message: `There should be at least one space before and exactly one space after '${operatorToken.value}'`,
 
           fix(fixer) {
-            return fixer.replaceTextRange(
-              [sourceCode.getTokenBefore(operatorToken).range[1], sourceCode.getTokenAfter(operatorToken).range[0]],
-              ` ${operatorName} `
-            );
+            const fixes = [];
+
+            if (!hasSpaceBefore && /^[ \t]*$/.test(beforeText)) {
+              fixes.push(fixer.replaceTextRange(
+                [tokenBefore.range[1], operatorToken.range[0]],
+                " "
+              ));
+            }
+
+            if (!hasOneSpaceAfter && /^[ \t]*$/.test(afterText)) {
+              fixes.push(fixer.replaceTextRange(
+                [operatorToken.range[1], tokenAfter.range[0]],
+                " "
+              ));
+            }
+
+            return fixes.length ? fixes : null;
           }
         });
       }
@@ -45,20 +75,35 @@ export default {
 
     return {
       AssignmentExpression(node) {
-        const operatorToken = sourceCode.getTokenBefore(node.right);
-        checkSpacing(node, operatorToken, "=");
+        const operatorToken = sourceCode.getFirstTokenBetween(
+          node.left,
+          node.right,
+          token => token.value === node.operator
+        );
+
+        checkSpacing(operatorToken);
       },
       VariableDeclarator(node) {
         if (node.init) {
-          const operatorToken = sourceCode.getTokenBefore(node.init);
-          checkSpacing(node, operatorToken, "=");
+          const operatorToken = sourceCode.getFirstTokenBetween(
+            node.id,
+            node.init,
+            token => token.value === "="
+          );
+
+          checkSpacing(operatorToken);
         }
       },
 
       Property(node) {
-        if (checkColon) {
-          const operatorToken = sourceCode.getTokenBefore(node.value);
-          checkSpacing(node, operatorToken, ":");
+        if (checkColon && !node.method && !node.shorthand) {
+          const operatorToken = sourceCode.getFirstTokenBetween(
+            node.key,
+            node.value,
+            token => token.value === ":"
+          );
+
+          checkSpacing(operatorToken);
         }
       },
     };

package/rules/vue-header-check.js

@@ -15,13 +15,14 @@ export default {
   create(context) {
     return {
       Program(node) {
-        const fileName = context.getFilename();
-        const fileContent = fs.readFileSync(path.resolve(fileName), "utf8");
+        const fileName = context.physicalFilename || context.filename || context.getFilename();
 
         // Determine the file extension
         const fileExtension = path.extname(fileName);
 
         if (fileExtension === ".vue") {
+          const fileContent = fs.readFileSync(path.resolve(fileName), "utf8");
+
           // Define the headers
           const headers = ["TEMPLATE", "SCRIPT", "STYLE"];
 
@@ -31,7 +32,7 @@ export default {
           // Check each tag individually
           vueTags.forEach((tag, index) => {
             const tagRegExp = new RegExp(`<${tag}`);
-            const headerRegExp = new RegExp(`\\n\\n<!--\\s*\\*{70,73}\\s*\\n\\s{5}${headers[index]}\\s*\\n\\s*\\*{70,73}\\s*-->\\s*\\n\\n<${tag}`);
+            const headerRegExp = new RegExp(`(?:^|\\n\\n)<!--\\s*\\*{70,73}\\s*\\n\\s{5}${headers[index]}\\s*\\n\\s*\\*{70,73}\\s*-->\\s*\\n\\n<${tag}`);
 
             // If the tag exists without the corresponding header, report an error
             if (tagRegExp.test(fileContent) && !headerRegExp.test(fileContent)) {

package/rules/vue-no-regex-data.js

@@ -5,8 +5,7 @@ export default {
       description: "disallow regex in Vue data object",
       category: "Possible Errors",
       recommended: true,
-    },
-    fixable: "code",
+    }
   },
 
   create(context) {

package/rules/vue-pinia-action-single-parameter.js

@@ -0,0 +1,158 @@
+const MESSAGE_ID = "singlePayloadArgument";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Pinia actions to accept at most one payload argument",
+      category: "Possible Errors",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      [MESSAGE_ID]: "Pinia actions must accept at most one payload argument. Wrap multiple values in an object."
+    }
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+    const defineStoreImports = collectDefineStoreImports(sourceCode.ast);
+
+    return {
+      CallExpression(node) {
+        if (!isImportedDefineStoreCall(node, sourceCode, defineStoreImports)) {
+          return;
+        }
+
+        const options = node.arguments[1];
+
+        if (!options || options.type !== "ObjectExpression") {
+          return;
+        }
+
+        const actions = findObjectProperty(options, "actions");
+
+        if (!actions || actions.value.type !== "ObjectExpression") {
+          return;
+        }
+
+        for (const property of actions.value.properties) {
+          const action = getActionFunction(property);
+
+          if (
+            action &&
+            (
+              action.params.length > 1 ||
+              action.params.some((parameter) => parameter.type === "RestElement")
+            )
+          ) {
+            context.report({
+              node: action,
+              messageId: MESSAGE_ID
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// Collects local bindings for named defineStore imports from Pinia
+function collectDefineStoreImports(program) {
+  const imports = new Map();
+
+  for (const node of program.body) {
+    if (node.type !== "ImportDeclaration" || node.source.value !== "pinia") {
+      continue;
+    }
+
+    for (const specifier of node.specifiers) {
+      if (
+        specifier.type === "ImportSpecifier" &&
+        getImportedName(specifier) === "defineStore"
+      ) {
+        imports.set(specifier.local.name, specifier);
+      }
+    }
+  }
+
+  return imports;
+}
+
+// Returns the imported name for JavaScript and TypeScript ESTree nodes
+function getImportedName(specifier) {
+  return specifier.imported.name || specifier.imported.value;
+}
+
+// Checks that a call resolves to the collected Pinia import, rather than a shadow
+function isImportedDefineStoreCall(node, sourceCode, defineStoreImports) {
+  if (
+    node.callee.type !== "Identifier" ||
+    !defineStoreImports.has(node.callee.name)
+  ) {
+    return false;
+  }
+
+  const expectedSpecifier = defineStoreImports.get(node.callee.name);
+  let scope = sourceCode.getScope(node);
+
+  while (scope) {
+    const variable = scope.variables.find(({ name }) => name === node.callee.name);
+
+    if (variable) {
+      return variable.defs.some((definition) => {
+        return (
+          definition.type === "ImportBinding" &&
+          definition.node === expectedSpecifier
+        );
+      });
+    }
+
+    scope = scope.upper;
+  }
+
+  return false;
+}
+
+// Finds a direct, statically named property in an object expression
+function findObjectProperty(object, name) {
+  return object.properties.find((property) => {
+    return (
+      property.type === "Property" &&
+      property.kind === "init" &&
+      getStaticPropertyName(property) === name
+    );
+  });
+}
+
+// Returns a property's static name, including quoted property names
+function getStaticPropertyName(property) {
+  if (!property.computed && property.key.type === "Identifier") {
+    return property.key.name;
+  }
+
+  if (property.key.type === "Literal") {
+    return property.key.value;
+  }
+
+  return null;
+}
+
+// Returns a directly declared action function
+function getActionFunction(property) {
+  if (
+    property.type !== "Property" ||
+    property.kind !== "init"
+  ) {
+    return null;
+  }
+
+  if (
+    property.value.type === "FunctionExpression" ||
+    property.value.type === "ArrowFunctionExpression"
+  ) {
+    return property.value;
+  }
+
+  return null;
+}