eslint-plugin-greasemonkey 1.0.0 → 1.2.0

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

@@ -1,60 +1,79 @@
-import { extractMetadata } from '../utils.js'
-
-const RE_SEMVER = /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?(?:\+[0-9a-z.-]+)?$/i
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Validate values of metadata fields',
-            category: 'Possible Errors',
-            recommended: true
-        },
-        schema: [{
-            type: 'object',
-            properties: {
-                reVer: {
-                    type: 'string',
-                    description: 'Regular expression pattern for @version validation (default: ^\\d+\\.\\d+\\.\\d+$)'
-                },
-                allowedGrants: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Allowed @grant values to check against; if empty, no grant validation'
-                }
-            },
-            additionalProperties: false
-        }],
-        defaultOptions: [{}],
-        messages: {
-            invalidVersion: 'Invalid @version: must match pattern "{{pattern}}"',
-            invalidURL: 'Invalid URL for @{{field}}',
-            invalidGrant: 'Unknown @grant: "{{grant}}"'
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {},
-              reVer = options.reVer || '^\\d+\\.\\d+\\.\\d+$',
-              allowedGrants = options.allowedGrants || []
-        return {
-            Program() {
-                const metaEntries = extractMetadata(context.sourceCode)
-                for (const entry of metaEntries) {
-                    if (entry.key == 'version') {
-                        if (!RE_SEMVER.test(entry.value) && !(new RegExp(reVer).test(entry.value)))
-                            context.report({
-                                node: entry.comment, messageId: 'invalidVersion', data: { pattern: reVer }})
-                    }
-                    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 }})
-                }
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+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+)?$/,
+    urlSuffix: /url$/i,
+    whitespace: /\s+/
+} /* eslint-enable security/detect-unsafe-regex */
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Validate values of metadata fields',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                versionType: {
+                    type: 'string',
+                    enum: ['semver', 'date'],
+                    description: 'Version format to enforce (default: semver)'
+                },
+                allowedGrants: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Allowed @grant values to check against; if empty, no grant validation'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{}],
+        messages: {
+            invalidVersion: 'Invalid @version: must be a valid {{versionType}} (expected format: {{example}})',
+            invalidURL: 'Invalid URL for @{{field}}',
+            invalidGrant: 'Unknown @grant: "{{grant}}"'
+        }
+    },
+
+    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'
+        return {
+            Program() {
+                const metaEntries = extractMetadata(context.sourceCode)
+                for (const entry of metaEntries) {
+                    if (entry.key == 'version') {
+                        const isValid = versionType == 'semver' ? re.semVer.test(entry.value)
+                                      : versionType == 'date' ? re.dateVer.test(entry.value)
+                                      : false
+                        if (!isValid)
+                            context.report({
+                                node: entry.comment, messageId: 'invalidVersion', data: { versionType, example }})
+                    }
+                    if (['homepage', 'icon', 'icon64', 'require', 'source', 'website'].includes(entry.key)
+                        || re.urlSuffix.test(entry.key)
+                    )
+                        try { new URL(entry.value) }
+                        catch {
+                            context.report({ node: entry.comment, messageId: 'invalidURL', data: { field: entry.key }})
+                        }
+                    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 }})
+                        }
+                    }
+                    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,79 @@
+import { extractMetadata } from '../utils.js'
+
+const gm_legacy_apis = new Set([ /* eslint-disable no-secrets/no-secrets */
+    'GM_addElement', 'GM_addStyle', 'GM_addValueChangeListener', 'GM_deleteValue', 'GM_download',
+    'GM_getResourceText', 'GM_getResourceURL', 'GM_getTab', 'GM_getTabs', 'GM_getValue', 'GM_getValues',
+    'GM_info', 'GM_listValues', 'GM_log', 'GM_notification', 'GM_openInTab', 'GM_registerMenuCommand',
+    'GM_removeValueChangeListener', 'GM_saveTab', 'GM_setClipboard', 'GM_setValue', 'GM_setValues',
+    'GM_unregisterMenuCommand', 'GM_webRequest', 'GM_xmlhttpRequest'
+]) /* eslint-enable no-secrets/no-secrets */
+
+const gm_modern_apis = new Set([
+    'GM.addElement', 'GM.addStyle', 'GM.addValueChangeListener', 'GM.deleteValue', 'GM.download',
+    'GM.getResourceText', 'GM.getResourceUrl', 'GM.getValue', 'GM.info', 'GM.listValues', 'GM.log',
+    'GM.notification', 'GM.openInTab', 'GM.registerMenuCommand', 'GM.removeValueChangeListener',
+    'GM.setClipboard', 'GM.setValue', 'GM.unregisterMenuCommand', 'GM.xmlHttpRequest'
+])
+
+const sc_apis = new Set([
+    'CAT.agent.conversation', 'CAT.agent.dom', 'CAT.agent.mcp', 'CAT.agent.model',
+    'CAT.agent.opfs', 'CAT.agent.skills', 'CAT.agent.task',
+    'CAT_fileStorage', 'CAT_scriptLoaded', 'CAT_userConfig'
+])
+
+const specialGrants = new Set([
+    'none', 'unsafeWindow', 'window.close', 'window.focus', 'window.onurlchange'
+])
+
+const grants = new Set([...gm_legacy_apis, ...gm_modern_apis, ...sc_apis, ...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(e => e.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())
+                    if (suggestion)
+                        context.report({
+                            node: grant.comment, messageId: 'wrongCase',
+                            data: { grant: grantName, suggestion }})
+                    else
+                        context.report({
+                            node: grant.comment, messageId: 'invalidGrant', data: { grant: grantName }})
+                }
+            }
+        }
+    }
+}

package/src/utils.js

@@ -1,19 +1,19 @@
-export function extractMetadata(sourceCode) {
-    const comments = sourceCode.getAllComments(),
-          metaEntries = []
-    let inMetaBlock = false
-    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('@')) {
-            const spaceIdx = text.indexOf(' ')
-            if (spaceIdx > 1) { // '@' at 0, key starts at 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 })
-            }
-        }
-    }
-    return metaEntries
-}
+export function extractMetadata(sourceCode) {
+    const comments = sourceCode.getAllComments(),
+          metaEntries = []
+    let inMetaBlock
+    for (const comment of comments) {
+        const text = comment.value.trim()
+        if (!inMetaBlock && text == '==UserScript==') { inMetaBlock = true ; continue }
+        else if (inMetaBlock && text == '==/UserScript==') break
+        else if (inMetaBlock && text.startsWith('@')) { // capture entry
+            const spaceIdx = text.indexOf(' ')
+            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 })
+            }
+        }
+    }
+    return metaEntries
+}