@lvce-editor/eslint-plugin-github-actions 11.1.0 → 12.0.0

package/dist/index.js

@@ -4,14 +4,14 @@ import { existsSync } from 'fs';
 import { resolve, relative } from 'path';
 
 const config = {
-  ubuntu: ['ubuntu-24.04', 'ubuntu-24.04-arm'],
   macos: ['macos-15', 'macos-26'],
+  ubuntu: ['ubuntu-24.04', 'ubuntu-24.04-arm'],
   windows: ['windows-2025', 'windows-11-arm']
 };
 const platforms = {
-  windows: 'windows',
+  macos: 'macos',
   ubuntu: 'ubuntu',
-  macos: 'macos'
+  windows: 'windows'
 };
 const actions = {
   'actions/cache': ['actions/cache@v5'],
@@ -30,8 +30,8 @@ const npmCommands = ['run', 'test', 'publish', 'install', 'ci'];
 const shells = ['bash'];
 const pythonVersions = ['3.13', '3.14', '3.15'];
 const permissions$1 = {
-  'id-token': ['write'],
   contents: ['write'],
+  'id-token': ['write'],
   pages: ['write']
 };
 
@@ -39,14 +39,14 @@ const isSupported = (actions, value) => {
   return actions.includes(value);
 };
 const meta$g = {
-  type: 'problem',
   docs: {
     description: 'Disallow unsupported action versions'
   },
+  fixable: 'code',
   messages: {
     unsupportedActionVersion: 'Unsupported action version: {{value}}'
   },
-  fixable: 'code'
+  type: 'problem'
 };
 const create$g = context => {
   const sourceCode = getSourceCode(context);
@@ -60,15 +60,15 @@ const create$g = context => {
         for (const [key, value] of Object.entries(actions)) {
           if (nodeValue.startsWith(key) && !isSupported(value, nodeValue)) {
             context.report({
-              node: node.value,
-              messageId: 'unsupportedActionVersion',
               data: {
                 value: nodeValue
               },
               fix(fixer) {
                 const validText = value.at(-1) || '';
                 return fixer.replaceText(node.value, validText);
-              }
+              },
+              messageId: 'unsupportedActionVersion',
+              node: node.value
             });
           }
         }
@@ -105,13 +105,13 @@ const isSupportedWindowsVersion = version => {
   return config.windows.includes(version);
 };
 const meta$f = {
-  type: 'problem',
   docs: {
     description: 'Disallow unsupported ci versions'
   },
   messages: {
     unsupportedCiVersion: 'Unsupported ci version: {{value}}'
-  }
+  },
+  type: 'problem'
 };
 const create$f = context => {
   const sourceCode = getSourceCode(context);
@@ -119,17 +119,17 @@ const create$f = context => {
     return {};
   }
   const checks = [{
-    prefix: `${platforms.ubuntu}-`,
+    isSupported: isSupportedUbuntuVersion,
     parseVersion: parseUbuntuVersion,
-    isSupported: isSupportedUbuntuVersion
+    prefix: `${platforms.ubuntu}-`
   }, {
-    prefix: `${platforms.macos}-`,
+    isSupported: isSupportedMacosversion,
     parseVersion: parseMacosVersion,
-    isSupported: isSupportedMacosversion
+    prefix: `${platforms.macos}-`
   }, {
-    prefix: `${platforms.windows}-`,
+    isSupported: isSupportedWindowsVersion,
     parseVersion: parseWindowsVersion,
-    isSupported: isSupportedWindowsVersion
+    prefix: `${platforms.windows}-`
   }];
   return {
     YAMLScalar(node) {
@@ -140,11 +140,11 @@ const create$f = context => {
             const isSupported = check.isSupported(version);
             if (!isSupported) {
               context.report({
-                node,
-                messageId: 'unsupportedCiVersion',
                 data: {
                   value: node.value
-                }
+                },
+                messageId: 'unsupportedCiVersion',
+                node
               });
             }
           }
@@ -161,13 +161,13 @@ const ciVersions = {
 };
 
 const meta$e = {
-  type: 'problem',
   docs: {
     description: 'Disallow unsupported fail fast values'
   },
   messages: {
     unsupportedFailFast: 'Unsupported fail fast value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
 const create$e = context => {
   const sourceCode = getSourceCode(context);
@@ -179,11 +179,11 @@ const create$e = context => {
       if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'fail-fast' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLScalar' && typeof node.value.value !== 'boolean') {
         const nodeValue = node.value.value;
         context.report({
-          node: node.value,
-          messageId: 'unsupportedFailFast',
           data: {
             value: nodeValue
-          }
+          },
+          messageId: 'unsupportedFailFast',
+          node: node.value
         });
       }
     }
@@ -197,15 +197,53 @@ const failFast = {
 };
 
 const meta$d = {
-  type: 'problem',
+  docs: {
+    description: 'Disallow unsupported github token values'
+  },
+  messages: {
+    unsupportedGithubToken: 'Unsupported github token value: {{value}}'
+  },
+  type: 'problem'
+};
+const create$d = context => {
+  const sourceCode = getSourceCode(context);
+  if (!sourceCode.parserServices?.isYAML) {
+    return {};
+  }
+  return {
+    YAMLPair(node) {
+      if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'GITHUB_TOKEN' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLScalar') {
+        const nodeValue = node.value.value;
+        if (typeof nodeValue !== 'string' || nodeValue !== '${{ secrets.GITHUB_TOKEN }}') {
+          context.report({
+            data: {
+              value: nodeValue
+            },
+            messageId: 'unsupportedGithubToken',
+            node
+          });
+        }
+      }
+    }
+  };
+};
+
+const githubToken = {
+  __proto__: null,
+  create: create$d,
+  meta: meta$d
+};
+
+const meta$c = {
   docs: {
     description: 'Disallow unsupported matrix values'
   },
   messages: {
     unsupportedMatrix: 'Unsupported matrix value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$d = context => {
+const create$c = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -214,12 +252,12 @@ const create$d = context => {
     YAMLPair(node) {
       if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'matrix' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type !== 'YAMLSequence') {
         context.report({
-          node,
-          messageId: 'unsupportedMatrix',
           data: {
             // @ts-ignore
             value: node.value
-          }
+          },
+          messageId: 'unsupportedMatrix',
+          node
         });
       }
     }
@@ -228,20 +266,20 @@ const create$d = context => {
 
 const matrix = {
   __proto__: null,
-  create: create$d,
-  meta: meta$d
+  create: create$c,
+  meta: meta$c
 };
 
-const meta$c = {
-  type: 'problem',
+const meta$b = {
   docs: {
     description: 'Disallow unsupported max parallel values'
   },
   messages: {
     unsupportedMaxParallel: 'Unsupported max parallel value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$c = context => {
+const create$b = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -251,11 +289,11 @@ const create$c = context => {
       if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'max-parallel' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLScalar' && typeof node.value.value !== 'number') {
         const nodeValue = node.value.value;
         context.report({
-          node,
-          messageId: 'unsupportedMaxParallel',
           data: {
             value: nodeValue
-          }
+          },
+          messageId: 'unsupportedMaxParallel',
+          node
         });
       }
     }
@@ -264,33 +302,35 @@ const create$c = context => {
 
 const maxParallel = {
   __proto__: null,
-  create: create$c,
-  meta: meta$c
+  create: create$b,
+  meta: meta$b
 };
 
-const meta$b = {
-  type: 'problem',
+const meta$a = {
   docs: {
     description: 'Disallow unsupported needs values'
   },
   messages: {
     unsupportedNeeds: 'Unsupported needs value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
 const stringifyValue = node => {
   if (!node) {
     return '';
   }
   if (node.type === 'YAMLScalar') {
-    return `${node.value}`;
+    return String(node.value);
   }
-  return `${node.type}`;
+  return node.type;
 };
 const getValidNeeds = node => {
   const greatGrandParent = node.parent.parent.parent;
   const validNeeds = [];
   if (greatGrandParent.type === 'YAMLMapping') {
-    const pairs = greatGrandParent.pairs;
+    const {
+      pairs
+    } = greatGrandParent;
     for (const pair of pairs) {
       if (pair.key && pair.key.type === 'YAMLScalar' && typeof pair.key.value === 'string') {
         validNeeds.push(pair.key.value);
@@ -299,7 +339,7 @@ const getValidNeeds = node => {
   }
   return validNeeds;
 };
-const create$b = context => {
+const create$a = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -311,11 +351,11 @@ const create$b = context => {
         if (node.value.type === 'YAMLScalar' && typeof node.value.value === 'string') {
           if (!validNeeds.includes(node.value.value)) {
             context.report({
-              node,
-              messageId: 'unsupportedNeeds',
               data: {
                 value: stringifyValue(node.value)
-              }
+              },
+              messageId: 'unsupportedNeeds',
+              node
             });
           }
           return;
@@ -324,32 +364,32 @@ const create$b = context => {
           for (const item of node.value.entries) {
             if (!item || item.type !== 'YAMLScalar' || typeof item.value !== 'string') {
               context.report({
-                node,
-                messageId: 'unsupportedNeeds',
                 data: {
                   value: stringifyValue(item)
-                }
+                },
+                messageId: 'unsupportedNeeds',
+                node
               });
               continue;
             }
             if (!validNeeds.includes(item.value)) {
               context.report({
-                node,
-                messageId: 'unsupportedNeeds',
                 data: {
                   value: stringifyValue(item)
-                }
+                },
+                messageId: 'unsupportedNeeds',
+                node
               });
             }
           }
           return;
         }
         context.report({
-          node,
-          messageId: 'unsupportedNeeds',
           data: {
             value: stringifyValue(node.value)
-          }
+          },
+          messageId: 'unsupportedNeeds',
+          node
         });
       }
     }
@@ -358,20 +398,20 @@ const create$b = context => {
 
 const needs = {
   __proto__: null,
-  create: create$b,
-  meta: meta$b
+  create: create$a,
+  meta: meta$a
 };
 
-const meta$a = {
-  type: 'problem',
+const meta$9 = {
   docs: {
     description: 'Disallow unsupported node version file values'
   },
   messages: {
     unsupportedNodeVersionFile: 'Unsupported node version file value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$a = context => {
+const create$9 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -382,11 +422,11 @@ const create$a = context => {
         const nodeValue = node.value.value;
         if (typeof nodeValue !== 'string' || nodeValue !== '.nvmrc') {
           context.report({
-            node,
-            messageId: 'unsupportedNodeVersionFile',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'unsupportedNodeVersionFile',
+            node
           });
         }
       }
@@ -396,20 +436,20 @@ const create$a = context => {
 
 const nodeVersionFile = {
   __proto__: null,
-  create: create$a,
-  meta: meta$a
+  create: create$9,
+  meta: meta$9
 };
 
-const meta$9 = {
-  type: 'problem',
+const meta$8 = {
   docs: {
     description: 'Disallow unsupported npm registry values'
   },
   messages: {
     unsupportedNpmRegistry: 'Unsupported npm registry value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$9 = context => {
+const create$8 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -420,11 +460,11 @@ const create$9 = context => {
         const nodeValue = node.value.value;
         if (typeof nodeValue !== 'string' || !npmRegistries.includes(nodeValue)) {
           context.report({
-            node,
-            messageId: 'unsupportedNpmRegistry',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'unsupportedNpmRegistry',
+            node
           });
         }
       }
@@ -434,18 +474,18 @@ const create$9 = context => {
 
 const npmRegistry = {
   __proto__: null,
-  create: create$9,
-  meta: meta$9
+  create: create$8,
+  meta: meta$8
 };
 
-const meta$8 = {
-  type: 'problem',
+const meta$7 = {
   docs: {
     description: 'Disallow unsupported npm commands'
   },
   messages: {
     unsupportedNpmCommand: 'Unsupported npm command: {{value}}'
-  }
+  },
+  type: 'problem'
 };
 const isSupportedNpmCommand = value => {
   for (const npmCommand of npmCommands) {
@@ -455,7 +495,7 @@ const isSupportedNpmCommand = value => {
   }
   return false;
 };
-const create$8 = context => {
+const create$7 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -468,11 +508,11 @@ const create$8 = context => {
           const rest = nodeValue.slice('npm '.length);
           if (!isSupportedNpmCommand(rest)) {
             context.report({
-              node: node.value,
-              messageId: 'unsupportedNpmCommand',
               data: {
                 value: nodeValue
-              }
+              },
+              messageId: 'unsupportedNpmCommand',
+              node: node.value
             });
           }
         }
@@ -483,20 +523,20 @@ const create$8 = context => {
 
 const npm = {
   __proto__: null,
-  create: create$8,
-  meta: meta$8
+  create: create$7,
+  meta: meta$7
 };
 
-const meta$7 = {
-  type: 'problem',
+const meta$6 = {
   docs: {
     description: 'Disallow unsupported on values'
   },
   messages: {
     unsupportedOn: 'Unsupported on value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$7 = context => {
+const create$6 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -504,15 +544,17 @@ const create$7 = context => {
   return {
     YAMLPair(node) {
       if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'on' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLMapping') {
-        const pairs = node.value.pairs;
+        const {
+          pairs
+        } = node.value;
         for (const pair of pairs) {
           if (pair.key && pair.key.type === 'YAMLScalar' && typeof pair.key.value === 'string' && !onProperties.includes(pair.key.value)) {
             context.report({
-              node,
-              messageId: 'unsupportedOn',
               data: {
                 value: pair.key.value
-              }
+              },
+              messageId: 'unsupportedOn',
+              node
             });
           }
         }
@@ -523,20 +565,20 @@ const create$7 = context => {
 
 const on = {
   __proto__: null,
-  create: create$7,
-  meta: meta$7
+  create: create$6,
+  meta: meta$6
 };
 
-const meta$6 = {
-  type: 'problem',
+const meta$5 = {
   docs: {
     description: 'Disallow unsupported permission values'
   },
   messages: {
     unsupportedPermission: 'Unsupported permission value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$6 = context => {
+const create$5 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -547,29 +589,29 @@ const create$6 = context => {
         for (const pair of node.value.pairs) {
           if (pair.key && pair.key.type === 'YAMLScalar' && typeof pair.key.value === 'string') {
             const supportedKey = Object.hasOwn(permissions$1, pair.key.value);
-            if (!supportedKey) {
-              context.report({
-                node: pair.key,
-                messageId: 'unsupportedPermission',
-                data: {
-                  // @ts-ignore
-                  value: pair
-                }
-              });
-            } else {
+            if (supportedKey) {
               if (pair.value && pair.value.type === 'YAMLScalar' && typeof pair.value.value === 'string') {
                 const items = permissions$1[pair.key.value] || [];
                 if (!items.includes(pair.value.value)) {
                   context.report({
-                    node,
-                    messageId: 'unsupportedPermission',
                     data: {
                       // @ts-ignore
                       value: pair.value
-                    }
+                    },
+                    messageId: 'unsupportedPermission',
+                    node
                   });
                 }
               }
+            } else {
+              context.report({
+                data: {
+                  // @ts-ignore
+                  value: pair
+                },
+                messageId: 'unsupportedPermission',
+                node: pair.key
+              });
             }
           }
         }
@@ -580,20 +622,20 @@ const create$6 = context => {
 
 const permissions = {
   __proto__: null,
-  create: create$6,
-  meta: meta$6
+  create: create$5,
+  meta: meta$5
 };
 
-const meta$5 = {
-  type: 'problem',
+const meta$4 = {
   docs: {
     description: 'Disallow unsupported python versions'
   },
   messages: {
     unsupportedPythonVersion: 'Unsupported python version: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$5 = context => {
+const create$4 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -604,11 +646,11 @@ const create$5 = context => {
         const nodeValue = node.value.value;
         if (typeof nodeValue !== 'string' || !pythonVersions.includes(nodeValue)) {
           context.report({
-            node,
-            messageId: 'unsupportedPythonVersion',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'unsupportedPythonVersion',
+            node
           });
         }
       }
@@ -618,20 +660,72 @@ const create$5 = context => {
 
 const pythonVersion = {
   __proto__: null,
-  create: create$5,
-  meta: meta$5
+  create: create$4,
+  meta: meta$4
 };
 
-const meta$4 = {
-  type: 'problem',
+const meta$3 = {
+  docs: {
+    description: 'Disallow unsupported release action usage'
+  },
+  fixable: 'code',
+  messages: {
+    unsupportedReleaseAction: 'Unsupported release action'
+  },
+  type: 'problem'
+};
+const create$3 = context => {
+  const sourceCode = getSourceCode(context);
+  if (!sourceCode.parserServices?.isYAML) {
+    return {};
+  }
+  return {
+    YAMLPair(node) {
+      if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'uses' && node.value && node.value.type === 'YAMLScalar' && node.value.value === 'actions/create-release@v1') {
+        context.report({
+          data: {},
+          fix(fixer) {
+            const edits = [];
+            const {
+              parent
+            } = node;
+            edits.push(fixer.replaceText(node.value, 'softprops/action-gh-release@v2'));
+            for (const pair of parent.pairs) {
+              if (pair.key && pair.key.type === 'YAMLScalar' && pair.key.value === 'with' && pair.value?.type == 'YAMLMapping') {
+                const subPairs = pair.value.pairs;
+                for (const subPair of subPairs) {
+                  if (subPair.key?.type === 'YAMLScalar' && subPair.key.value === 'release_name') {
+                    edits.push(fixer.replaceText(subPair.key, 'name'));
+                  }
+                }
+              }
+            }
+            return edits;
+          },
+          messageId: 'unsupportedReleaseAction',
+          node
+        });
+      }
+    }
+  };
+};
+
+const releaseAction = {
+  __proto__: null,
+  create: create$3,
+  meta: meta$3
+};
+
+const meta$2 = {
   docs: {
     description: 'Disallow unsupported shell values'
   },
   messages: {
     unsupportedShell: 'Unsupported shell value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$4 = context => {
+const create$2 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -642,11 +736,11 @@ const create$4 = context => {
         const nodeValue = node.value.value;
         if (typeof nodeValue !== 'string' || !shells.includes(nodeValue)) {
           context.report({
-            node,
-            messageId: 'unsupportedShell',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'unsupportedShell',
+            node
           });
         }
       }
@@ -656,20 +750,20 @@ const create$4 = context => {
 
 const shell = {
   __proto__: null,
-  create: create$4,
-  meta: meta$4
+  create: create$2,
+  meta: meta$2
 };
 
-const meta$3 = {
-  type: 'problem',
+const meta$1 = {
   docs: {
     description: 'Disallow unsupported timeout minute values'
   },
   messages: {
     unsupportedTimeoutMinutes: 'Unsupported timeout minutes value: {{value}}'
-  }
+  },
+  type: 'problem'
 };
-const create$3 = context => {
+const create$1 = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -679,11 +773,11 @@ const create$3 = context => {
       if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'timeout-minutes' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLScalar' && typeof node.value.value !== 'number') {
         const nodeValue = node.value.value;
         context.report({
-          node: node.value,
-          messageId: 'unsupportedTimeoutMinutes',
           data: {
             value: nodeValue
-          }
+          },
+          messageId: 'unsupportedTimeoutMinutes',
+          node: node.value
         });
       }
     }
@@ -692,19 +786,19 @@ const create$3 = context => {
 
 const timeoutMinutes = {
   __proto__: null,
-  create: create$3,
-  meta: meta$3
+  create: create$1,
+  meta: meta$1
 };
 
-const meta$2 = {
-  type: 'problem',
+const meta = {
   docs: {
     description: 'Disallow non-existing working directories'
   },
   messages: {
     invalidWorkingDirectory: 'Working directory not found: {{value}}',
     workingDirectoryMustBeOfTypeString: 'Working directory must be of type string'
-  }
+  },
+  type: 'problem'
 };
 const allowedNonExistingWorkingDirectories = ['dist', '.tmp'];
 const isAllowedNonExistingWorkingDirectory = relativePath => {
@@ -715,7 +809,7 @@ const isAllowedNonExistingWorkingDirectory = relativePath => {
   }
   return false;
 };
-const create$2 = context => {
+const create = context => {
   const sourceCode = getSourceCode(context);
   if (!sourceCode.parserServices?.isYAML) {
     return {};
@@ -726,11 +820,11 @@ const create$2 = context => {
         const nodeValue = node.value.value;
         if (typeof nodeValue !== 'string') {
           context.report({
-            node,
-            messageId: 'workingDirectoryMustBeOfTypeString',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'workingDirectoryMustBeOfTypeString',
+            node
           });
           return;
         }
@@ -738,11 +832,11 @@ const create$2 = context => {
         const relativePath = relative(context.cwd, path);
         if (!isAllowedNonExistingWorkingDirectory(relativePath) && !existsSync(path)) {
           context.report({
-            node,
-            messageId: 'invalidWorkingDirectory',
             data: {
               value: nodeValue
-            }
+            },
+            messageId: 'invalidWorkingDirectory',
+            node
           });
         }
       }
@@ -751,94 +845,6 @@ const create$2 = context => {
 };
 
 const workingDirectory = {
-  __proto__: null,
-  create: create$2,
-  meta: meta$2
-};
-
-const meta$1 = {
-  type: 'problem',
-  docs: {
-    description: 'Disallow unsupported github token values'
-  },
-  messages: {
-    unsupportedGithubToken: 'Unsupported github token value: {{value}}'
-  }
-};
-const create$1 = context => {
-  const sourceCode = getSourceCode(context);
-  if (!sourceCode.parserServices?.isYAML) {
-    return {};
-  }
-  return {
-    YAMLPair(node) {
-      if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'GITHUB_TOKEN' && node.value && typeof node.value === 'object' && 'type' in node.value && node.value.type === 'YAMLScalar') {
-        const nodeValue = node.value.value;
-        if (typeof nodeValue !== 'string' || nodeValue !== '${{ secrets.GITHUB_TOKEN }}') {
-          context.report({
-            node,
-            messageId: 'unsupportedGithubToken',
-            data: {
-              value: nodeValue
-            }
-          });
-        }
-      }
-    }
-  };
-};
-
-const githubToken = {
-  __proto__: null,
-  create: create$1,
-  meta: meta$1
-};
-
-const meta = {
-  type: 'problem',
-  docs: {
-    description: 'Disallow unsupported release action usage'
-  },
-  messages: {
-    unsupportedReleaseAction: 'Unsupported release action'
-  },
-  fixable: 'code'
-};
-const create = context => {
-  const sourceCode = getSourceCode(context);
-  if (!sourceCode.parserServices?.isYAML) {
-    return {};
-  }
-  return {
-    YAMLPair(node) {
-      if (node && node.type === 'YAMLPair' && node.key && typeof node.key === 'object' && 'type' in node.key && node.key.type === 'YAMLScalar' && typeof node.key.value === 'string' && node.key.value === 'uses' && node.value && node.value.type === 'YAMLScalar' && node.value.value === 'actions/create-release@v1') {
-        context.report({
-          node,
-          messageId: 'unsupportedReleaseAction',
-          data: {},
-          fix(fixer) {
-            const edits = [];
-            const parent = node.parent;
-            edits.push(fixer.replaceText(node.value, 'softprops/action-gh-release@v2'));
-            for (const pair of parent.pairs) {
-              if (pair.key && pair.key.type === 'YAMLScalar' && pair.key.value === 'with' && pair.value?.type == 'YAMLMapping') {
-                const subPairs = pair.value.pairs;
-                for (const subPair of subPairs) {
-                  if (subPair.key?.type === 'YAMLScalar' && subPair.key.value === 'release_name') {
-                    edits.push(fixer.replaceText(subPair.key, 'name'));
-                  }
-                }
-              }
-            }
-            return edits;
-          }
-        });
-      }
-    }
-  };
-};
-
-const releaseAction = {
   __proto__: null,
   create,
   meta
@@ -854,29 +860,29 @@ const plugin = {
     'ci-versions': ciVersions,
     'fail-fast': failFast,
     'github-token': githubToken,
+    matrix: matrix,
     'max-parallel': maxParallel,
+    needs: needs,
     'node-version-file': nodeVersionFile,
+    npm: npm,
     'npm-registry': npmRegistry,
+    on: on,
+    permissions,
     'python-version': pythonVersion,
     'release-action': releaseAction,
+    shell,
     'timeout-minutes': timeoutMinutes,
-    'working-directory': workingDirectory,
-    matrix: matrix,
-    needs: needs,
-    npm: npm,
-    on: on,
-    permissions,
-    shell
+    'working-directory': workingDirectory
   }
 };
 const recommended = [{
-  plugins: {
-    'github-actions': plugin
-  },
   files: ['**/.github/workflows/*.y?(a)ml'],
   languageOptions: {
     parser: parserYAML
   },
+  plugins: {
+    'github-actions': plugin
+  },
   rules: {
     'github-actions/action-versions': 'error',
     'github-actions/ci-versions': 'error',
@@ -886,8 +892,8 @@ const recommended = [{
     'github-actions/max-parallel': 'error',
     'github-actions/needs': 'error',
     'github-actions/node-version-file': 'error',
-    'github-actions/npm-registry': 'error',
     'github-actions/npm': 'error',
+    'github-actions/npm-registry': 'error',
     'github-actions/on': 'error',
     'github-actions/permissions': 'off',
     'github-actions/python-version': 'error',

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@lvce-editor/eslint-plugin-github-actions",
-  "version": "11.1.0",
+  "version": "12.0.0",
   "main": "dist/index.js",
   "type": "module",
-  "keywords": [],
   "license": "MIT",
   "description": "Lint github action workflows.",
   "repository": {