eslint-plugin-greasemonkey 1.1.0 → 1.3.0

package/src/rules/require-user-js-filename.js

@@ -0,0 +1,25 @@
+import { extractMetadata } from '../utils.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require that userscript filenames end in ".user.js"',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: { requireUserJS: 'Userscript filename should end in ".user.js"' }
+    },
+
+    create(context) {
+        return {
+            Program(node) {
+                const metaEntries = extractMetadata(context.sourceCode)
+                if (!metaEntries.length) return
+                if (!context.filename.endsWith('.user.js'))
+                    context.report({ node, messageId: 'requireUserJS' })
+            }
+        }
+    }
+}

package/src/rules/valid-field-values.js

@@ -1,9 +1,12 @@
 import { extractMetadata } from '../utils.js'
 
-const re = {
-    semVer: /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?(?:\+[0-9a-z.-]+)?$/i,
-    dateVer: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/
-}
+const re = { /* eslint-disable security/detect-unsafe-regex */
+    semVer: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i,
+    dateVer: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
+    whitespace: /\s+/
+} /* eslint-enable security/detect-unsafe-regex */
+
+const urlKeys = ['homepage', 'icon', 'icon64', 'require', 'source', 'website']
 
 export default {
     meta: {
@@ -40,13 +43,26 @@ export default {
     create(context) {
         const options = context.options[0] || {},
               versionType = options.versionType || 'semver',
-              allowedGrants = options.allowedGrants || []
-        const example = versionType == 'semver' ? '1.2.3' : 'YYYY.M.D or YYYY.MM.DD'
+              allowedGrants = options.allowedGrants || [],
+              example = versionType == 'semver' ? '1.2.3' : 'YYYY.M.D or YYYY.MM.DD'
         return {
             Program() {
                 const metaEntries = extractMetadata(context.sourceCode)
                 for (const entry of metaEntries) {
-                    if (entry.key == 'version') {
+                    if (entry.key == 'grant' && allowedGrants.length && !allowedGrants.includes(entry.value))
+                        context.report({ node: entry.comment, messageId: 'invalidGrant', data: { grant: entry.value }})
+                    else if (entry.key == 'resource') {
+                        const url = entry.value.trim().split(re.whitespace)[1]
+                        if (url) try { new URL(url) }
+                        catch {
+                            context.report({ node: entry.comment, messageId: 'invalidURL', data: { field: entry.key }})
+                        }
+                    } else if (urlKeys.includes(entry.key) || entry.key.toLowerCase().endsWith('url'))
+                        try { new URL(entry.value) }
+                        catch {
+                            context.report({ node: entry.comment, messageId: 'invalidURL', data: { field: entry.key }})
+                        }
+                    else if (entry.key == 'version') {
                         const isValid = versionType == 'semver' ? re.semVer.test(entry.value)
                                       : versionType == 'date' ? re.dateVer.test(entry.value)
                                       : false
@@ -54,13 +70,6 @@ export default {
                             context.report({
                                 node: entry.comment, messageId: 'invalidVersion', data: { versionType, example }})
                     }
-                    if (['homepage', 'icon', 'updateURL', 'downloadURL', 'supportURL'].includes(entry.key))
-                        try { new URL(entry.value) }
-                        catch {
-                            context.report({ node: entry.comment, messageId: 'invalidURL', data: { field: entry.key }})
-                        }
-                    if (entry.key == 'grant' && allowedGrants.length && !allowedGrants.includes(entry.value))
-                        context.report({ node: entry.comment, messageId: 'invalidGrant', data: { grant: entry.value }})
                 }
             }
         }

package/src/rules/valid-grants.js

@@ -0,0 +1,56 @@
+import { extractMetadata } from '../utils.js'
+import { gmLegacyAPIs, gmModernAPIs, scAPIs } from '../apis.js'
+
+const specialGrants = new Set([
+    'none', 'unsafeWindow', 'window.close', 'window.focus', 'window.onurlchange'
+])
+
+const grants = new Set([...gmLegacyAPIs, ...gmModernAPIs, ...scAPIs, ...specialGrants]),
+      sortedGrants = new Map(Array.from(grants, grant => [grant.toLowerCase(), grant]))
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow invalid @grant values',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedGrants: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Additional @grant values to allow beyond the built-in list'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{}],
+        messages: {
+            invalidGrant: 'Invalid @grant: "{{grant}}"',
+            wrongCase: 'Invalid @grant: "{{grant}}" (did you mean "{{suggestion}}"?)'
+        }
+    },
+
+    create(context) {
+        const options = context.options[0] || {},
+              allowedGrants = options.allowedGrants || []
+        return {
+            Program() {
+                const metaEntries = extractMetadata(context.sourceCode),
+                      grantEntries = metaEntries.filter(entry => entry.key == 'grant')
+                for (const grant of grantEntries) {
+                    const grantName = grant.value.trim()
+                    if (grants.has(grantName) || allowedGrants.includes(grantName)) continue
+                    const suggestion = sortedGrants.get(grantName.toLowerCase())
+                    context.report(suggestion
+                        ? { node: grant.comment, messageId: 'wrongCase', data: { grant: grantName, suggestion }}
+                        : { node: grant.comment, messageId: 'invalidGrant', data: { grant: grantName }}
+                    )
+                }
+            }
+        }
+    }
+}

package/src/utils.js

@@ -1,14 +1,14 @@
 export function extractMetadata(sourceCode) {
     const comments = sourceCode.getAllComments(),
           metaEntries = []
-    let inMetaBlock = false
+    let inMetaBlock
     for (const comment of comments) {
         const text = comment.value.trim()
-        if (!inMetaBlock && text == '==UserScript==') { inMetaBlock = true ; continue }
-        if (inMetaBlock && text == '==/UserScript==') break
-        if (inMetaBlock && text.startsWith('@')) {
+        if (!inMetaBlock && text == '==UserScript==') inMetaBlock = true
+        else if (inMetaBlock && text == '==/UserScript==') break
+        else if (inMetaBlock && text.startsWith('@')) { // capture entry
             const spaceIdx = text.indexOf(' ')
-            if (spaceIdx > 1) { // '@' at 0, key starts at 1, need space after key
+            if (spaceIdx > 1) { // need space after key
                 const key = text.slice(1, spaceIdx).trim(),
                       value = text.slice(spaceIdx +1).trim()
                 metaEntries.push({ key, value, comment, line: comment.loc.start.line })
@@ -17,3 +17,22 @@ export function extractMetadata(sourceCode) {
     }
     return metaEntries
 }
+
+export function resolveTemplate(node) {
+    if (node.type == 'ConditionalExpression') {
+        const branches = [node.consequent, node.alternate].map(resolveTemplate)
+        return branches.every(Boolean) ? branches.flat() : null
+    } else if (node.type == 'Literal' && ['number', 'string'].includes(typeof node.value))
+        return [String(node.value)]
+    else if (node.type == 'TemplateLiteral') // build every combo of quasis + resolved expressions
+        return node.quasis.reduce((combos, quasi, idx) => {
+            if (!combos) return null
+            const withQuasi = combos.map(combo => combo + quasi.value.raw)
+            if (idx >= node.expressions.length) return withQuasi
+            const vals = // eslint-disable-next-line security/detect-object-injection -- AST array indices are bounded
+                resolveTemplate(node.expressions[idx])
+            return vals ? withQuasi.flatMap(combo => vals.map(val => combo + val)) : null
+        }, [''])
+    else
+        return null
+}