eslint-plugin-greasemonkey 1.9.0 → 1.10.0

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

@@ -1,4 +1,4 @@
-const re = { whitespace: /\s/ }
+import regex from '../data/regex.js'
 
 export default {
     createBlock(...entries) {
@@ -20,7 +20,7 @@ export default {
             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),
+                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 })

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/template.js

@@ -11,7 +11,7 @@ export default {
                     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]) // eslint-disable-line security/detect-object-injection -- AST array indices are bounded
+                    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