eslint-plugin-greasemonkey 1.8.4 → 1.10.0

package/src/utils/init.js

@@ -0,0 +1,106 @@
+import deprecations from './deprecations.js'
+import pkg from './pkg.js'
+import rulesUtils from './rules.js'
+
+import headers from '../data/headers.js'
+import { rules as deprecationsData } from '../data/deprecations.js'
+
+import metaOrder from '../rules/meta-order.js'
+import metaSpacing from '../rules/meta-spacing.js'
+import noDuplicateKeys from '../rules/no-duplicate-keys.js'
+import noInsecureFetch from '../rules/no-insecure-fetch.js'
+import noInsecureMessaging from '../rules/no-insecure-messaging.js'
+import noInvalidGrants from '../rules/no-invalid-grants.js'
+import noInvalidHeaders from '../rules/no-invalid-headers.js'
+import noMissingGrants from '../rules/no-missing-grants.js'
+import noMissingResources from '../rules/no-missing-resources.js'
+import noSensitiveGrants from '../rules/no-sensitive-grants.js'
+import noUnusedGrants from '../rules/no-unused-grants.js'
+import noUnusedResources from '../rules/no-unused-resources.js'
+import preferGMaddStyle from '../rules/prefer-gm-add-style.js'
+import preferMatch from '../rules/prefer-match.js'
+import requireBlankLineAfterMetaBlock from '../rules/require-blank-line-after-meta-block.js'
+import requireHomepagePair from '../rules/require-homepage-pair.js'
+import requireLicenseHeader from '../rules/require-license-header.js'
+import requireMatchingLocalizedFields from '../rules/require-matching-localized-fields.js'
+import requireRequiredFields from '../rules/require-required-fields.js'
+import requireSpaceBeforeMetaKey from '../rules/require-space-before-meta-key.js'
+import requireSRIhashing from '../rules/require-sri-hashing.js'
+import requireUpdateDownloadPair from '../rules/require-update-download-pair.js'
+import requireUserJsFilename from '../rules/require-user-js-filename.js'
+import validFieldValues from '../rules/valid-field-values.js'
+import validIconHeaders from '../rules/valid-icon-headers.js'
+import validLicenseHeader from '../rules/valid-license-header.js'
+import validUrlHeaders from '../rules/valid-url-headers.js'
+import validVersionHeader from '../rules/valid-version-header.js'
+
+const pkgName = pkg.getName(),
+      namespace = pkgName.replace(/^@[^/]+\//, '').replace(/^eslint-plugin-/, '')
+
+export default {
+    configs(plugin) {
+        const plugins = { [namespace]: plugin },
+              rules = plugin.rules,
+              createConfig = predicate => ({ plugins, rules: rulesUtils.bundle(rules, predicate, namespace) })
+        plugin.configs = {
+            recommended: createConfig(rule => rule.meta.docs.recommended),
+            strict: createConfig(() => true),
+            problem: createConfig(rule => rule.meta.type == 'problem'),
+            security: createConfig(rule => rule.meta.docs.security),
+            stylistic: createConfig(rule => rule.meta.docs.category == 'Stylistic Issues')
+        }
+        for (const manager of headers.managers)
+            plugin.configs[manager] = { // oxlint-disable-line security/detect-object-injection
+                plugins,
+                rules: {
+                    ...plugin.configs.recommended.rules,
+                    [`${namespace}/no-invalid-grants`]: ['error', { target: manager }],
+                    [`${namespace}/no-invalid-headers`]: ['error', { target: manager }],
+                    ...(['tampermonkey', 'scriptcat', 'adguard'].includes(manager) &&
+                        { [`${namespace}/require-update-download-pair`]: 'error' })
+                }
+            }
+    },
+
+    deprecations(plugin) {
+        for (const entry of Object.entries(deprecationsData))
+            deprecations.initAlias(plugin, entry)
+    },
+
+    plugin() { return { meta: { name: pkgName }, rules: {}, configs: {} }},
+
+    rules(plugin) {
+        plugin.rules = {
+            'meta-order': metaOrder,
+            'meta-spacing': metaSpacing,
+            'no-duplicate-keys': noDuplicateKeys,
+            'no-insecure-fetch': noInsecureFetch,
+            'no-insecure-messaging': noInsecureMessaging,
+            'no-invalid-grants': noInvalidGrants,
+            'no-invalid-headers': noInvalidHeaders,
+            'no-missing-grants': noMissingGrants,
+            'no-missing-resources': noMissingResources,
+            'no-sensitive-grants': noSensitiveGrants,
+            'no-unused-grants': noUnusedGrants,
+            'no-unused-resources': noUnusedResources,
+            'prefer-gm-add-style': preferGMaddStyle,
+            'prefer-match': preferMatch,
+            'require-blank-line-after-meta-block': requireBlankLineAfterMetaBlock,
+            'require-homepage-pair': requireHomepagePair,
+            'require-license-header': requireLicenseHeader,
+            'require-matching-localized-fields': requireMatchingLocalizedFields,
+            'require-required-fields': requireRequiredFields,
+            'require-space-before-meta-key': requireSpaceBeforeMetaKey,
+            'require-sri-hashing': requireSRIhashing,
+            'require-update-download-pair': requireUpdateDownloadPair,
+            'require-user-js-filename': requireUserJsFilename,
+            'valid-field-values': validFieldValues,
+            'valid-icon-headers': validIconHeaders,
+            'valid-license-header': validLicenseHeader,
+            'valid-url-headers': validUrlHeaders,
+            'valid-version-header': validVersionHeader
+        }
+        for (const [ruleId, rule] of Object.entries(plugin.rules))
+            rule.meta.docs.url = `https://codeberg.org/adamlui/${pkgName}/#${ruleId}`
+    }
+}

package/src/utils/license.js

@@ -0,0 +1,56 @@
+// oxlint-disable security/detect-non-literal-fs-filename
+
+import { createRequire } from 'node:module'
+import fs from 'node:fs'
+import path from 'node:path'
+
+import regex from '../data/regex.js'
+
+const re = { spdxTag: /SPDX-License-Identifier:\s*([\w.-]+)/i },
+      require = createRequire(import.meta.url),
+      skipDirs = new Set(['node_modules']),
+      spdxIDs = new Set(require('spdx-license-ids')),
+      spdxNames = Object.entries(require('spdx-license-list'))
+          .map(([id, { name }]) => ({ id, name }))
+          .sort((a, b) => b.name.length - a.name.length)
+
+function tryReaddir(dir) { try { return fs.readdirSync(dir, { withFileTypes: true }) } catch { return null }}
+
+export default {
+    find(root) {
+        const queue = [root]
+        while (queue.length) {
+            const dir = queue.shift(), entries = tryReaddir(dir)
+            if (!entries) continue
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || skipDirs.has(entry.name)) continue
+                if (entry.isFile() &&  regex.filename.license.test(entry.name)) return path.join(dir, entry.name)
+                if (entry.isDirectory()) queue.push(path.join(dir, entry.name))
+            }
+        }
+        return null
+    },
+
+    spdx: {
+        appendTag(fixer, text, id) {
+            const nl = text.includes('\r\n') ? '\r\n' : '\n',
+                  trailer = `${text.endsWith(nl) ? '' : nl}${nl}SPDX-License-Identifier: ${id}${nl}`
+            return fixer.insertTextAfterRange([0, text.length], trailer)
+        },
+
+        find(text) {
+            const normalizedTxt = text.replace(/\s+/g, ' ')
+            let best = null
+            for (const { id, name } of spdxNames) {
+                const idx = normalizedTxt.indexOf(name)
+                if (idx == -1) continue
+                if (!best || idx < best.idx || (idx == best.idx && name.length > best.name.length))
+                    best = { id, idx, name }
+            }
+            return best?.id ?? null
+        },
+
+        isValid(id) { return spdxIDs.has(id) },
+        parse(text) { return text.match(re.spdxTag)?.[1] ?? null }
+    }
+}

package/src/utils/metadata.js

@@ -0,0 +1,31 @@
+import regex from '../data/regex.js'
+
+export default {
+    createBlock(...entries) {
+        const lines = ['// ==UserScript==']
+        for (const entry of entries)
+            lines.push(typeof entry == 'string'
+                ? `// ${entry}`
+                : `// @${entry.key}${entry.value ? ` ${entry.value}` : ''}`)
+        lines.push('// ==/UserScript==')
+        return lines.join('\n') + '\n'
+    },
+
+    extract(sourceCode) {
+        const comments = sourceCode.getAllComments(),
+              metaEntries = []
+        let inMetaBlock
+        for (const comment of comments) {
+            const text = comment.value.trim()
+            if (!inMetaBlock && text == '==UserScript==') inMetaBlock = true
+            else if (inMetaBlock && text == '==/UserScript==') break
+            else if (inMetaBlock && text.startsWith('@')) { // capture entry
+                const spaceIdx = text.search(regex.whitespace.all),
+                      key = ( spaceIdx == -1 ? text.slice(1) : text.slice(1, spaceIdx) ).trim(),
+                      value = spaceIdx == -1 ? '' : text.slice(spaceIdx +1).trim()
+                if (key) metaEntries.push({ key, value, comment, line: comment.loc.start.line })
+            }
+        }
+        return metaEntries
+    }
+}

package/src/utils/pkg.js

@@ -0,0 +1,21 @@
+import { fileURLToPath } from 'node:url'
+import fs from 'node:fs'
+import path from 'node:path'
+
+export default {
+    getName() { // oxlint-disable security/detect-non-literal-fs-filename
+        let current = path.dirname(fileURLToPath(import.meta.url))
+        while (current) {
+            const pkgPath = path.join(current, 'package.json')
+            if (fs.existsSync(pkgPath))
+                try {
+                    const { name } = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+                    if (name) return name
+                } catch { /* malformed, keep walking */ }
+            const parent = path.dirname(current)
+            if (parent === current) return null
+            current = parent
+        }
+        return null
+    } // oxlint-enable security/detect-non-literal-fs-filename
+}

package/src/utils/rules.js

@@ -0,0 +1,7 @@
+export default {
+    bundle(rules, predicate, pluginName) {
+        return Object.fromEntries(Object.entries(rules)
+            .filter(([, rule]) => !rule.meta.deprecated && predicate(rule))
+            .map(([ruleId]) => [`${pluginName}/${ruleId}`, 'error']))
+    }
+}

package/src/utils/template.js

@@ -0,0 +1,21 @@
+export default {
+    resolve(node) {
+        function walk(n) {
+            if (n.type == 'ConditionalExpression') {
+                const branches = [n.consequent, n.alternate].map(walk)
+                return branches.every(Boolean) ? branches.flat() : null
+            } else if (n.type == 'Literal' && ['number', 'string'].includes(typeof n.value))
+                return [String(n.value)]
+            else if (n.type == 'TemplateLiteral')
+                return n.quasis.reduce((combos, quasi, idx) => {
+                    if (!combos) return null
+                    const withQuasi = combos.map(combo => combo + quasi.value.raw)
+                    if (idx >= n.expressions.length) return withQuasi
+                    const vals = walk(n.expressions[idx]) // oxlint-disable-line security/detect-object-injection
+                    return vals ? withQuasi.flatMap(combo => vals.map(val => combo + val)) : null
+                }, [''])
+            else return null
+        }
+        return walk(node)
+    }
+}

package/src/utils.js

@@ -1,119 +0,0 @@
-const re = { whitespace: /\s/ }
-
-export function bundleRules(rules, predicate, pluginName) {
-    return Object.fromEntries(Object.entries(rules)
-        .filter(([, rule]) => predicate(rule))
-        .map(([ruleId]) => [`${pluginName}/${ruleId}`, 'error']))
-}
-
-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
-        else if (inMetaBlock && text == '==/UserScript==') break
-        else if (inMetaBlock && text.startsWith('@')) { // capture entry
-            const spaceIdx = text.search(re.whitespace),
-                  key = ( spaceIdx == -1 ? text.slice(1) : text.slice(1, spaceIdx) ).trim(),
-                  value = spaceIdx == -1 ? '' : text.slice(spaceIdx +1).trim()
-            if (key) metaEntries.push({ key, value, comment, line: comment.loc.start.line })
-        }
-    }
-    return metaEntries
-}
-
-export function initDeprecatedAlias(plugin, [oldName, alias]) { /* eslint-disable security/detect-object-injection */
-    const routes = typeof alias == 'string' ? { [alias]: null } // 'old-rule': 'new-rule'
-        : Array.isArray(alias) ? Object.fromEntries(alias.map(entry =>
-              typeof entry == 'string' ? [entry, null] // ['new-rule-1', 'new-rule-2']
-            : Object.entries(entry)[0])) // [{ 'new-rule': { 'old-opt': 'new-opt' }}]
-        : alias // { 'new-rule': null | { 'new-opt': default } | { 'old-val': 'new-val' } | { ..., 'new-opt': default }}
-    const targetNames = Object.keys(routes),
-          isRename = !targetNames.includes(oldName),
-          originals = Object.fromEntries(targetNames.map(name => [name, plugin.rules[name]])),
-          source = originals[oldName] ?? originals[targetNames[0]]
-    plugin.rules[oldName] = {
-        meta: {
-            ...source.meta,
-            defaultOptions: [],
-            schema: [{ type: ['object', 'array', 'string', 'number', 'boolean', 'null'] }],
-            docs: { ...source.meta.docs, recommended: isRename ? false : source.meta.docs.recommended },
-            messages: {
-                ...source.meta.messages,
-                deprecatedOption: `'{{old}}' is deprecated. Use '{{new}}' instead.`
-            },
-            ...(isRename ? { deprecated: {
-                message: `Use ${targetNames.map(name => `\`${name}\``).join(', ')} instead.`,
-                replacedBy: targetNames.map(name => ({ rule: { name }}))
-            }} : {})
-        },
-        create(context) {
-            const opts = context.options[0],
-                  isObj = opts?.constructor === Object
-            return Object.assign({}, ...Object.entries(routes).map(([targetName, mapping]) => {
-                let newOpts = opts, deprecation
-                if (mapping) {
-                    const entries = Object.entries(mapping),
-                          namedRemap = entries.every(([, val]) => typeof val == 'string'),
-                          wrapKey = namedRemap && entries.length > 1 ? entries.at(-1)[0] : null,
-                          valMap = wrapKey ? Object.fromEntries(entries.slice(0, -1)) : mapping
-                    if (namedRemap) {
-                        if (typeof opts == 'string') { // bare old val → remap, optionally wrapped
-                            if (valMap[opts]) deprecation = { old: opts, new: valMap[opts] }
-                            const remapped = valMap[opts] ?? opts
-                            newOpts = wrapKey ? { [wrapKey]: remapped } : remapped
-                        } else if (wrapKey) { // object opts (or defaults) → remap inner val, warn if deprecated
-                            const raw = isObj ? (opts[wrapKey] ?? mapping[wrapKey]) : mapping[wrapKey],
-                                  remapped = valMap[raw]
-                            if (remapped) deprecation = { old: raw, new: remapped }
-                            newOpts = { [wrapKey]: remapped ?? raw }
-                        } else { // object opts → old key → new key
-                            newOpts = { ...opts }
-                            for (const [oldKey, newKey] of entries)
-                                if (opts?.[oldKey] !== undefined) {
-                                    newOpts[newKey] = opts[oldKey] ; delete newOpts[oldKey] }
-                        }
-                    } else { // { new-opt: default } — positional wrap
-                        const [newKey, defaultValue] = entries[0]
-                        if (opts !== undefined && !isObj)
-                            deprecation = { old: JSON.stringify(opts), new: `{ ${newKey}: ${JSON.stringify(opts)} }` }
-                        newOpts = { [newKey]: isObj ? (opts[newKey] ?? defaultValue) : (opts ?? defaultValue) }
-                    }
-                }
-                const aliasContext = Object.create(context)
-                Object.defineProperty(aliasContext, 'options',
-                    { value: [newOpts], writable: true, configurable: true, enumerable: true })
-                const visitors = { ...originals[targetName].create(aliasContext) }
-                if (deprecation) {
-                    const ruleProgram = visitors.Program
-                    visitors.Program = function(node) {
-                        context.report({ node, messageId: 'deprecatedOption', data: deprecation })
-                        if (ruleProgram) ruleProgram.call(this, node)
-                    }
-                }
-                return visitors
-            }))
-        }
-    }
-} /* eslint-enable security/detect-object-injection */
-
-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
-}