eslint-plugin-chrome-extensions 2.4.2 → 2.6.0

package/src/utils/init.js

@@ -0,0 +1,107 @@
+import css from '@eslint/css'
+import html from '@html-eslint/eslint-plugin'
+import json from '@eslint/json'
+import rulesUtils from './rules.js'
+import text from './text.js'
+
+import manifestKeyOrder from '../rules/manifest-key-order.js'
+import manifestSpacing from '../rules/manifest-spacing.js'
+import noContentStyleLeak from '../rules/no-content-style-leak.js'
+import noDeprecatedAPIs from '../rules/no-deprecated-apis.js'
+import noDuplicateManifestKeys from '../rules/no-duplicate-manifest-keys.js'
+import noInsecureFetch from '../rules/no-insecure-fetch.js'
+import noInsecureMessaging from '../rules/no-insecure-messaging.js'
+import noInvalidLocales from '../rules/no-invalid-locales.js'
+import noInvalidPermissions from '../rules/no-invalid-permissions.js'
+import noMissingDefaultLocale from '../rules/no-missing-default-locale.js'
+import noMissingI18nKeys from '../rules/no-missing-i18n-keys.js'
+import noMissingPermissions from '../rules/no-missing-permissions.js'
+import noMissingWebAccessibleResources from '../rules/no-missing-web-accessible-resources.js'
+import noRemoteCode from '../rules/no-remote-code.js'
+import noSensitivePermissions from '../rules/no-sensitive-permissions.js'
+import noUnrestrictedHostPermissions from '../rules/no-unrestricted-host-permissions.js'
+import noUnusedI18nKeys from '../rules/no-unused-i18n-keys.js'
+import noUnusedPermissions from '../rules/no-unused-permissions.js'
+import requireLicenseFile from '../rules/require-license-file.js'
+import requireMV3 from '../rules/require-mv3.js'
+import requireShortNameWhenUseful from '../rules/require-short-name-when-useful.js'
+import validFilenames from '../rules/valid-filenames.js'
+import validLicenseFile from '../rules/valid-license-file.js'
+import validManifestIcons from '../rules/valid-manifest-icons.js'
+import validMV3schema from '../rules/valid-mv3-schema.js'
+import validServiceWorker from '../rules/valid-service-worker.js'
+import validURLfields from '../rules/valid-url-fields.js'
+import validVersionField from '../rules/valid-version-field.js'
+
+const namespace = 'chrome-extensions'
+
+export default {
+    bundleDeprecation(plugin, [ruleId, bundleNames], pluginName) { /* eslint-disable security/detect-object-injection */
+        for (const bundleName of bundleNames)
+            if (plugin.configs[bundleName])
+                plugin.configs[bundleName].rules[`${pluginName}/${ruleId}`] = 'error'
+    }, /* eslint-enable security/detect-object-injection */
+
+    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),
+            manifest: {
+                ...createConfig(rule => rule.meta.docs.manifest), language: 'json/json', plugins: { ...plugins, json }},
+            license: {
+                ...createConfig(rule => rule.meta.docs.license), languageOptions: { parser: text.parser }},
+            css: {
+                ...createConfig(rule => rule.meta.docs.css), language: 'css/css', plugins: { ...plugins, css }},
+            html: {
+                ...createConfig(rule => rule.meta.docs.html), language: 'html/html', plugins: { ...plugins, html }},
+            json: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/json', plugins: { ...plugins, json }},
+            json5: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/json5', plugins: { ...plugins, json }},
+            jsonc: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/jsonc', plugins: { ...plugins, json }}
+        }
+    },
+
+    plugin() { return { rules: {}, configs: {} }},
+
+    rules(plugin) {
+        plugin.rules = {
+            'manifest-key-order': manifestKeyOrder,
+            'manifest-spacing': manifestSpacing,
+            'no-content-style-leak': noContentStyleLeak,
+            'no-deprecated-apis': noDeprecatedAPIs,
+            'no-duplicate-manifest-keys': noDuplicateManifestKeys,
+            'no-insecure-fetch': noInsecureFetch,
+            'no-insecure-messaging': noInsecureMessaging,
+            'no-invalid-locales': noInvalidLocales,
+            'no-invalid-permissions': noInvalidPermissions,
+            'no-missing-default-locale': noMissingDefaultLocale,
+            'no-missing-i18n-keys': noMissingI18nKeys,
+            'no-missing-permissions': noMissingPermissions,
+            'no-missing-web-accessible-resources': noMissingWebAccessibleResources,
+            'no-remote-code': noRemoteCode,
+            'no-sensitive-permissions': noSensitivePermissions,
+            'no-unrestricted-host-permissions': noUnrestrictedHostPermissions,
+            'no-unused-i18n-keys': noUnusedI18nKeys,
+            'no-unused-permissions': noUnusedPermissions,
+            'require-mv3': requireMV3,
+            'require-license-file': requireLicenseFile,
+            'require-short-name-when-useful': requireShortNameWhenUseful,
+            'valid-filenames': validFilenames,
+            'valid-license-file': validLicenseFile,
+            'valid-manifest-icons': validManifestIcons,
+            'valid-mv3-schema': validMV3schema,
+            'valid-service-worker': validServiceWorker,
+            'valid-url-fields': validURLfields,
+            'valid-version-field': validVersionField
+        }
+        for (const [ruleId, rule] of Object.entries(plugin.rules))
+            rule.meta.docs.url = `https://codeberg.org/adamlui/eslint-plugin-${namespace}/#${ruleId}`
+    }
+}

package/src/utils/license.js

@@ -0,0 +1,56 @@
+/* eslint-disable security/detect-non-literal-fs-filename -- lint-time test fixtures only */
+
+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/node.js

@@ -1,22 +1,23 @@
-export function getMemberPath(node) {
-    const parts = []
-    let cur = node
-    while (cur?.type == 'MemberExpression') {
-        if (cur.computed || cur.property.type != 'Identifier') return null
-        parts.unshift(cur.property.name)
-        cur = cur.object
-    }
-    if (cur?.type != 'Identifier') return null
-    parts.unshift(cur.name)
-    return parts.join('.')
-}
+export default {
+    getMemberPath(node) {
+        const parts = [] ; let currentNode = node
+        while (currentNode?.type == 'MemberExpression') {
+            if (currentNode.computed || currentNode.property.type != 'Identifier') return null
+            parts.unshift(currentNode.property.name)
+            currentNode = currentNode.object
+        }
+        if (currentNode?.type != 'Identifier') return null
+        parts.unshift(currentNode.name)
+        return parts.join('.')
+    },
 
-export function isInsideNestedFunction(node) {
-    let current = node.parent
-    while (current) {
-        if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(current.type))
-            return true
-        current = current.parent
+    isInsideNestedFunction(node) {
+        let ancestor = node.parent
+        while (ancestor) {
+            if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(ancestor.type))
+                return true
+            ancestor = ancestor.parent
+        }
+        return false
     }
-    return false
 }

package/src/utils/pkg.js

@@ -1,19 +1,21 @@
 import fs from 'node:fs'
 import path from 'node:path'
 
-export function findRoot(dir) {
-    let current = path.resolve(dir)
-    while (true) {
-        if (current.split(path.sep).includes('node_modules')) {
+export default {
+    findRoot(dir) {
+        let current = path.resolve(dir)
+        while (true) {
+            if (current.split(path.sep).includes('node_modules')) {
+                const parent = path.dirname(current)
+                if (parent === current) return null
+                current = parent
+                continue
+            }
+            if ( // eslint-disable-next-line security/detect-non-literal-fs-filename
+                fs.existsSync(path.join(current, 'package.json'))) return current
             const parent = path.dirname(current)
             if (parent === current) return null
             current = parent
-            continue
         }
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        if (fs.existsSync(path.join(current, 'package.json'))) return current
-        const parent = path.dirname(current)
-        if (parent === current) return null
-        current = parent
     }
 }

package/src/utils/rules.js

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

package/src/utils/text.js

@@ -0,0 +1,13 @@
+export default {
+    parser: {
+        parse: text => ({
+            type: 'Program',
+            body: [],
+            sourceType: 'module',
+            range: [0, text.length],
+            loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 }},
+            tokens: [],
+            comments: []
+        })
+    }
+}

package/src/data/license.js

@@ -1,28 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-export const re = {
-    licenseFilename: // e.g. LICENSE.md, LICENSE-MIT, MIT-LICENSE.md, COPYING.LESSER, LICENSE-2.0.txt
-        // eslint-disable-next-line security/detect-unsafe-regex
-        /^(?!.*\.(?:[cm]?js|[cm]?ts)x?$)(?:[\w.-]*-)?(?:LICEN[SC]E|COPYING)(?:[-.][\w.-]+)?$/i,
-    spdxTag: /SPDX-License-Identifier:\s*([\w.+-]+)/i
-}
-
-export const skipDirs = new Set(['node_modules'])
-
-export function findLicenseFile(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() && re.licenseFilename.test(entry.name)) return path.join(dir, entry.name)
-            if (entry.isDirectory()) queue.push(path.join(dir, entry.name))
-        }
-    }
-    return null
-}
-
-function tryReaddir(dir) { // eslint-disable-next-line security/detect-non-literal-fs-filename
-    try { return fs.readdirSync(dir, { withFileTypes: true }) } catch { return null }}

package/src/data/text-parser.js

@@ -1,11 +0,0 @@
-export const textParser = {
-    parse: text => ({
-        type: 'Program',
-        body: [],
-        sourceType: 'module',
-        range: [0, text.length],
-        loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 }},
-        tokens: [],
-        comments: []
-    })
-}

package/src/utils/bundle.js

@@ -1,10 +0,0 @@
-export function initDeprecation(plugin, [ruleId, bundleNames], pluginName) {
-    for (const bundleName of bundleNames) {
-        /* eslint-disable security/detect-object-injection */
-        if (plugin.configs[bundleName])
-            plugin.configs[bundleName].rules[`${pluginName}/${ruleId}`] = 'error'
-        /* eslint-enable security/detect-object-injection */
-        if (process.env.DEBUG_MODE)
-            console.warn(`[${pluginName}] '${ruleId}' will be removed from '${bundleName}' in a future major release`)
-    }
-}