eslint-plugin-chrome-extensions 2.4.2 → 2.6.0

package/src/rules/no-missing-i18n-keys.js

@@ -1,8 +1,9 @@
-import { getMemberPath } from '../utils/node.js'
-import { readManifest } from '../utils/extension.js'
-import { findExtensionRoot, isPredefined, readDefaultLocaleMessages, re as i18nRe } from '../data/i18n.js'
+import extension from '../utils/extension.js'
+import i18nUtils from '../utils/i18n.js'
+import nodeUtils from '../utils/node.js'
 
-const re = { file: { js: /\.(cjs|js|jsx|mjs|ts|tsx)$/i, manifest: /manifest\.json$/, text: /\.(css|htm|html)$/i }}
+import i18nData from '../data/i18n.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -12,9 +13,7 @@ export default {
             category: 'Possible Errors',
             recommended: true,
             manifest: true,
-            css: true,
-            html: true,
-            json: true
+            css: true
         },
         schema: [{
             type: 'object',
@@ -33,41 +32,41 @@ export default {
     },
 
     create(context) {
-        const filename = context.filename
-        if (!filename || filename == '<input>') return {}
-        const manifest = readManifest(context) ; if (!manifest?.default_locale) return {}
-        const root = findExtensionRoot(filename) ; if (!root) return {}
-        const i18n = readDefaultLocaleMessages(manifest, root) ; if (!i18n) return {}
+        const filename = context.filename ; if (!filename || filename == '<input>') return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest?.default_locale) return {}
+        const root = extension.findRoot(context) ; if (!root) return {}
+        const i18n = i18nUtils.readDefaultLocaleMessages(manifest, root) ; if (!i18n) return {}
         const opts = context.options[0] || {},
               ignored = new Set(opts.ignoreKeys || []),
-              isMissing = key => !isPredefined(key) && !ignored.has(key) && !(key in i18n.messages),
+              isMissing = key => !i18nUtils.isPredefined(key) && !ignored.has(key) && !(key in i18n.messages),
               loc = { line: 1, column: 1 }
-        if (re.file.js.test(filename))
+        if (regex.filename.script.test(filename))
             return {
                 CallExpression(node) {
                     if (node.callee.type != 'MemberExpression') return
-                    const path = getMemberPath(node.callee)
-                    if (path != 'chrome.i18n.getMessage' && path != 'browser.i18n.getMessage') return
+                    const path = nodeUtils.getMemberPath(node.callee) ; if (!i18nData.re.getMsg.path.test(path)) return
                     const arg = node.arguments[0] ; if (!arg) return
                     let key
-                    if (arg.type == 'Literal' && typeof arg.value == 'string') key = arg.value
-                    else if (arg.type == 'TemplateLiteral' && arg.expressions.length == 0)
+                    if (arg.type == 'Literal' && typeof arg.value == 'string')
+                        key = arg.value
+                    else if (arg.type == 'TemplateLiteral' && arg.expressions.length === 0)
                         key = arg.quasis[0].value.cooked
                     if (key && isMissing(key))
                         context.report({ loc, messageId: 'missingKey', data: { key, locale: i18n.locale }})
                 }
             }
-        if (!re.file.text.test(filename) && !re.file.manifest.test(filename)) return {}
-        const seen = new Set()
-        const scanPlaceholders = () => {
-            for (const match of context.sourceCode.text.matchAll(i18nRe.msgPlaceholder)) {
+        if (!regex.filename.css.test(filename) && !regex.filename.manifest.test(filename))
+            return {}
+        const seenKeys = new Set()
+        function scanPlaceholders() {
+            for (const match of context.sourceCode.text.matchAll(i18nData.re.msgPlaceholder)) {
                 const key = match[1]
-                if (seen.has(key)) continue
-                seen.add(key)
+                if (seenKeys.has(key)) continue
+                seenKeys.add(key)
                 if (isMissing(key))
                     context.report({ loc, messageId: 'missingKey', data: { key, locale: i18n.locale }})
             }
         }
-        return { 'Document': scanPlaceholders, 'Program': scanPlaceholders }
+        return { 'Document': scanPlaceholders, 'Program': scanPlaceholders, 'StyleSheet': scanPlaceholders }
     }
 }

package/src/rules/no-missing-permissions.js

@@ -1,6 +1,7 @@
-import { findPermission } from '../data/apis.js'
-import { getMemberPath } from '../utils/node.js'
-import { readManifest } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import nodeUtils from '../utils/node.js'
+
+import apis from '../data/apis.js'
 
 function queriesActiveTab(node) {
     const arg = node.arguments[0] ; if (arg?.type != 'ObjectExpression') return false
@@ -27,13 +28,13 @@ export default {
     },
 
     create(context) {
-        const manifest = readManifest(context) ; if (!manifest) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
         const declared = new Set([...(manifest.permissions || []), ...(manifest.optional_permissions || [])])
         return {
             CallExpression(node) {
                 if (node.callee.type != 'MemberExpression') return
-                const api = getMemberPath(node.callee) ; if (!api) return
-                const permission = findPermission(api) ; if (!permission || declared.has(permission)) return
+                const api = nodeUtils.getMemberPath(node.callee) ; if (!api) return
+                const permission = apis.findPermission(api) ; if (!permission || declared.has(permission)) return
                 const isActiveTabQuery = permission == 'tabs' && queriesActiveTab(node)
                 if (isActiveTabQuery && declared.has('activeTab')) return
                 const messageId = `missing${ isActiveTabQuery ? 'ActiveTab' : 'Permission' }`

package/src/rules/no-missing-web-accessible-resources.js

@@ -1,5 +1,5 @@
-import { getMemberPath } from '../utils/node.js'
-import { file, readManifest } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import nodeUtils from '../utils/node.js'
 
 const re = { leadingSlash: /^\//, regexSpecial: /[.+?^${}()|[\]\\]/g }
 
@@ -35,13 +35,14 @@ export default {
     },
 
     create(context) {
-        const manifest = readManifest(context) ; if (!manifest) return {}
-        if (!file.isContentScript(context, manifest)) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
+        if (!extension.file.isContentScript(context, manifest)) return {}
         const regexes = collectWARpatterns(manifest).map(patternToRegex)
         return {
             CallExpression(node) {
-                if (node.callee.type != 'MemberExpression') return
-                if (getMemberPath(node.callee) != 'chrome.runtime.getURL') return
+                if (node.callee.type != 'MemberExpression'
+                    || nodeUtils.getMemberPath(node.callee) != 'chrome.runtime.getURL'
+                ) return
                 const arg = node.arguments[0] ; if (arg?.type != 'Literal' || typeof arg.value != 'string') return
                 const resourcePath = arg.value.replace(re.leadingSlash, '')
                 for (const regex of regexes) if (regex.test(resourcePath)) return

package/src/rules/no-remote-code.js

@@ -1,7 +1,7 @@
-import { remoteCodePatterns } from '../data/manifest.js'
-import { getMemberPath } from '../utils/node.js'
+import nodeUtils from '../utils/node.js'
 
-const re = { url: /^https?:\/\// }
+import manifest from '../data/manifest.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -22,7 +22,7 @@ export default {
             properties: {
                 patterns: {
                     type: 'array',
-                    items: { enum: remoteCodePatterns },
+                    items: { enum: manifest.patterns.remoteCode },
                     description: 'Detection paths to enable'
                 },
                 checkExecuteScriptClosures: {
@@ -45,7 +45,7 @@ export default {
 
     create(context) {
         const opts = context.options[0] || {},
-              patterns = new Set(opts.patterns || remoteCodePatterns),
+              patterns = new Set(opts.patterns || manifest.regexmoteCode),
               checkClosures = opts.checkExecuteScriptClosures !== false,
               scriptElems = new Set()
         function isCreateScript(node) {
@@ -53,10 +53,10 @@ export default {
                 && node.callee?.property?.name == 'createElement'
                 && node.arguments[0]?.value == 'script'
         }
-        function isLiteralUrl(node) {
+        function isLiteralURL(node) {
             return node?.type == 'Literal'
                 && typeof node.value == 'string'
-                && re.url.test(node.value)
+                && regex.url.test(node.value)
         }
         function isObjectAssign(node) {
             return node?.type == 'CallExpression'
@@ -67,7 +67,7 @@ export default {
         function isScriptSrcAssignment(left, right) {
             if (left.type != 'MemberExpression') return false
             if (left.property?.name != 'src') return false
-            if (!isLiteralUrl(right)) return false
+            if (!isLiteralURL(right)) return false
             if (isCreateScript(left.object)) return true
             if (left.object.type == 'Identifier' && scriptElems.has(left.object.name)) return true
             return false
@@ -87,7 +87,7 @@ export default {
             },
             ImportExpression(node) {
                 if (!patterns.has('dynamic-import')) return
-                if (isLiteralUrl(node.source))
+                if (isLiteralURL(node.source))
                     context.report({ node, messageId: 'dynamicImport' })
             },
             CallExpression(node) {
@@ -103,10 +103,10 @@ export default {
                 ) context.report({ node, messageId: 'stringTimer', data: { fn: node.callee.name }})
                 if (patterns.has('dynamic-import')
                     && node.callee.type == 'Import'
-                    && isLiteralUrl(node.arguments[0])
+                    && isLiteralURL(node.arguments[0])
                 ) context.report({ node, messageId: 'dynamicImport' })
                 if (node.callee.type == 'MemberExpression') {
-                    const path = getMemberPath(node.callee)
+                    const path = nodeUtils.getMemberPath(node.callee)
                     if (path == 'chrome.scripting.executeScript') {
                         const optsNode = node.arguments[0]
                         if (optsNode?.type != 'ObjectExpression') return
@@ -132,7 +132,7 @@ export default {
             Property(node) {
                 if (!patterns.has('remote-script-src')
                     || node.key?.name != 'src'
-                    || !isLiteralUrl(node.value)
+                    || !isLiteralURL(node.value)
                     || !isScriptSrcProperty(node)
                 ) return
                 context.report({ node: node.value, messageId: 'remoteScriptSrc' })

package/src/rules/no-sensitive-permissions.js

@@ -0,0 +1,75 @@
+import extension from '../utils/extension.js'
+
+import permissions from '../data/permissions.js'
+import regex from '../data/regex.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Flag sensitive permissions',
+            category: 'Possible Errors',
+            recommended: true,
+            security: true,
+            manifest: true
+        },
+        defaultOptions: [{ allowedPermissions: [] }],
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedPermissions: {
+                    oneOf: [
+                        { type: 'string', description: 'Single sensitive permission to allow' },
+                        {
+                            type: 'array',
+                            items: { type: 'string', description: 'Sensitive permission to allow' },
+                            description: 'List of sensitive permissions to allow'
+                        }
+                    ],
+                    description: 'Sensitive permission names to explicitly allow'
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            sensitivePermission: '`{{permission}}` is a sensitive permission. Review whether it\'s needed'
+                               + ' or add it to `allowedPermissions`.'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] || {},
+              allowed = new Set(Array.isArray(opts.allowedPermissions) ? opts.allowedPermissions
+                      : opts.allowedPermissions ? [opts.allowedPermissions] : [])
+        function checkPermission(node, permission) {
+            if (typeof permission != 'string') return
+            if (allowed.has(permission) || !permissions.sensitive.has(permission)) return
+            context.report({ node, messageId: 'sensitivePermission', data: { permission }})
+        }
+        if (regex.filename.manifest.test(extension.file.getName(context))) // lint it directly
+            return {
+                '*'(node) {
+                    const keyNode = node.name || node.key ; if (!keyNode) return
+                    const keyName = keyNode.value ?? keyNode.name
+                    if (keyName != 'permissions' && keyName != 'optional_permissions') return
+                    const arrNode = node.value ; if (arrNode?.type != 'Array') return
+                    const nodeElems = arrNode.elements || arrNode.items || []
+                    for (const elem of nodeElems) {
+                        const valueNode = elem.value || elem
+                        checkPermission(valueNode, valueNode?.value)
+                    }
+                }
+            }
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
+        const allPermissions = [...(manifest.permissions || []), ...(manifest.optional_permissions || [])]
+        return {
+            'Program:exit'() {
+                for (const permission of allPermissions) {
+                    if (allowed.has(permission) || !permissions.sensitive.has(permission)) continue
+                    context.report({ loc: { line: 1, column: 0 },
+                        messageId: 'sensitivePermission', data: { permission }})
+                }
+            }
+        }
+    }
+}

package/src/rules/no-unrestricted-host-permissions.js

@@ -1,6 +1,7 @@
-import { file } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
-const re = { broadHost: /^(?:<all_urls>|\*:\/\/\*\/\*|\w+:\/\/\*\/\*)$/, manifestFilename: /manifest\.json$/ },
+const re = { broadHost: /^(?:<all_urls>|\*:\/\/\*\/\*|\w+:\/\/\*\/\*)$/ },
       hostKeys = new Set(['host_permissions', 'optional_host_permissions', 'optional_permissions', 'permissions'])
 
 export default {
@@ -9,7 +10,8 @@ export default {
         docs: {
             description: 'Disallow broad host permissions that grant access to every site',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
+            security: true,
             manifest: true
         },
         defaultOptions: [{ allowedPatterns: [] }],
@@ -31,23 +33,37 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
-        const allowed = new Set(context.options[0]?.allowedPatterns || [])
+        const allowedPatterns = new Set(context.options[0]?.allowedPatterns || [])
+        function isBroad(pattern) {
+            return typeof pattern == 'string'
+                && !allowedPatterns.has(pattern)
+                && re.broadHost.test(pattern)
+        }
+        if (regex.filename.manifest.test(extension.file.getName(context))) // lint it directly
+            return {
+                '*'(node) {
+                    const keyNode = node.name || node.key ; if (!keyNode) return
+                    const keyName = keyNode.value ?? keyNode.name ; if (!hostKeys.has(keyName)) return
+                    const arrNode = node.value ; if (arrNode?.type != 'Array') return
+                    const nodeElems = arrNode.elements || arrNode.items || []
+                    for (const elem of nodeElems) {
+                        const valueNode = elem.value || elem,
+                              pattern = valueNode?.value
+                        if (!isBroad(pattern)) continue
+                        context.report({ node: valueNode, messageId: 'unrestrictedHost', data: { pattern }})
+                    }
+                }
+            }
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
         return {
-            '*'(node) {
-                const keyNode = node.name || node.key ; if (!keyNode) return
-                const keyName = keyNode.value ?? keyNode.name
-                if (!hostKeys.has(keyName)) return
-                const arrNode = node.value ; if (arrNode?.type != 'Array') return
-                const elems = arrNode.elements || arrNode.items || []
-                for (const elem of elems) {
-                    const valueNode = elem.value || elem,
-                          pattern = valueNode?.value
-                    if (typeof pattern != 'string'
-                        || allowed.has(pattern)
-                        || !re.broadHost.test(pattern)
-                    ) continue
-                    context.report({ node: valueNode, messageId: 'unrestrictedHost', data: { pattern }})
+            'Program:exit'() {
+                for (const key of hostKeys) {
+                    const patterns = manifest[key] // eslint-disable-line security/detect-object-injection
+                    if (!Array.isArray(patterns)) continue
+                    for (const pattern of patterns)
+                        if (isBroad(pattern))
+                            context.report({ loc: { line: 1, column: 1 },
+                                messageId: 'unrestrictedHost', data: { pattern }})
                 }
             }
         }

package/src/rules/no-unused-i18n-keys.js

@@ -1,7 +1,8 @@
-import { collectUsedKeys, defaultScanExtensions, findExtensionRoot, readDefaultLocaleMessages } from '../data/i18n.js'
-import { readManifest } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import i18nUtils from '../utils/i18n.js'
 
-const re = { manifestFile: /manifest\.json$/ }
+import i18nData from '../data/i18n.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -26,7 +27,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ ignoreKeys: [], scanExtensions: defaultScanExtensions }],
+        defaultOptions: [{ ignoreKeys: [], scanExtensions: i18nData.defaultScanExtensions }],
         messages: {
             unusedKey: '`{{key}}` in `_locales/{{locale}}/messages.json` is never referenced.'
         }
@@ -34,15 +35,15 @@ export default {
 
     create(context) {
         const filename = context.filename
-        if (!filename || !re.manifestFile.test(filename)) return {}
-        const manifest = readManifest(context) ; if (!manifest?.default_locale) return {}
-        const root = findExtensionRoot(filename) ; if (!root) return {}
-        const i18n = readDefaultLocaleMessages(manifest, root) ; if (!i18n) return {}
+        if (!filename || !regex.filename.manifest.test(filename)) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest?.default_locale) return {}
+        const root = extension.findRoot(context) ; if (!root) return {}
+        const i18n = i18nUtils.readDefaultLocaleMessages(manifest, root) ; if (!i18n) return {}
         const opts = context.options[0] || {},
               ignored = new Set(opts.ignoreKeys || []),
-              scanExtensions = opts.scanExtensions || defaultScanExtensions
+              scanExtensions = opts.scanExtensions || i18nData.defaultScanExtensions
         function check() {
-            const { used, patterns } = collectUsedKeys(root, scanExtensions)
+            const { used, patterns } = i18nUtils.collectUsedKeys(root, scanExtensions)
             for (const key of Object.keys(i18n.messages)) {
                 if (ignored.has(key) || used.has(key) || patterns.some(patt => patt.test(key))) continue
                 context.report({ loc: { line: 1, column: 1 }, messageId: 'unusedKey',

package/src/rules/no-unused-permissions.js

@@ -1,10 +1,9 @@
+import extension from '../utils/extension.js'
 import fs from 'node:fs'
 import path from 'node:path'
 
-import { apiPermissionMap, findPermission } from '../data/apis.js'
-import { file, findRoot as findExtensionRoot, readManifest } from '../utils/extension.js'
-
-const re = { manifestFilename: /manifest\.json$/ }
+import apis from '../data/apis.js'
+import regex from '../data/regex.js'
 
 function collectUsedAPIs(manifest, root) {
     const files = new Set()
@@ -34,7 +33,7 @@ export default {
         docs: {
             description: 'Flag manifest permissions whose APIs are never used',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [],
@@ -44,40 +43,49 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
-        const manifest = readManifest(context) ; if (!manifest) return {}
-        const root = findExtensionRoot(context) ; if (!root) return {}
+        const filename = extension.file.getName(context)
+        if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
+        const root = extension.findRoot(context) ; if (!root) return {}
         const usedAPIs = collectUsedAPIs(manifest, root)
-        const permissionNodes = new Map()
         function isUsed(permission) {
-            let known = false
-            for (const [, perm] of apiPermissionMap)
-                if (perm == permission) { known = true ; break }
-            if (!known) return true // custom permission → not our business
+            let knownPerm = false
+            for (const [, perm] of apis.permissionMap)
+                if (perm == permission) { knownPerm = true ; break }
+            if (!knownPerm) return true
             for (const api of usedAPIs)
-                if (findPermission(api) == permission) return true
+                if (apis.findPermission(api) == permission) return true
             return false
         }
+        if (!regex.filename.manifest.test(filename)) {
+            const loc = { line: 1, column: 1 },
+                  declared = [...(manifest.permissions || []), ...(manifest.optional_permissions || [])]
+            for (const permission of declared)
+                if (typeof permission == 'string' && !isUsed(permission))
+                    context.report({ loc, messageId: 'unusedPermission', data: { permission }})
+            return {}
+        }
+        const permissionNodes = new Map()
         return {
             '*'(node) {
                 const keyNode = node.name || node.key ; if (!keyNode) return
                 const keyName = keyNode.value ?? keyNode.name
                 if (keyName != 'permissions' && keyName != 'optional_permissions') return
                 const arrNode = node.value ; if (arrNode?.type != 'Array') return
-                const elems = arrNode.elements || arrNode.items || []
-                for (const elem of elems) {
-                    const valueNode = elem.value || elem
-                    const perm = valueNode?.value
-                    if (typeof perm != 'string') continue
-                    if (!permissionNodes.has(perm)) permissionNodes.set(perm, [])
-                    permissionNodes.get(perm).push(valueNode)
+                const nodeElems = arrNode.elements || arrNode.items || []
+                for (const elem of nodeElems) {
+                    const valueNode = elem.value || elem,
+                          permission = valueNode?.value
+                    if (typeof permission != 'string') continue
+                    if (!permissionNodes.has(permission)) permissionNodes.set(permission, [])
+                    permissionNodes.get(permission).push(valueNode)
                 }
             },
             'Document:exit'() {
                 for (const [permission, nodes] of permissionNodes) {
                     if (isUsed(permission)) continue
-                    for (const n of nodes)
-                        context.report({ node: n, messageId: 'unusedPermission', data: { permission }})
+                    for (const node of nodes)
+                        context.report({ node, messageId: 'unusedPermission', data: { permission }})
                 }
             }
         }

package/src/rules/require-license-file.js

@@ -1,7 +1,6 @@
+import license from '../utils/license.js'
 import path from 'node:path'
-
-import { findLicenseFile } from '../data/license.js'
-import { findRoot as findPkgRoot } from '../utils/pkg.js'
+import pkg from '../utils/pkg.js'
 
 export default {
     meta: {
@@ -20,8 +19,8 @@ export default {
     create(context) {
         const { filename } = context
         function check(node) {
-            const pkgRoot = findPkgRoot(path.dirname(filename))
-            if (!pkgRoot || !findLicenseFile(pkgRoot))
+            const pkgRoot = pkg.findRoot(path.dirname(filename))
+            if (!pkgRoot || !license.find(pkgRoot)) // eslint-disable-line e18e/prefer-array-some
                 context.report({ node, messageId: 'missingFile' })
         }
         return { Program: check, Document: check }

package/src/rules/require-mv3.js

@@ -1,6 +1,5 @@
-import { file, readManifest } from '../utils/extension.js'
-
-const re = { manifestFilename: /manifest\.json$/ }
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -8,7 +7,7 @@ export default {
         docs: {
             description: 'Require manifest_version 3',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [],
@@ -18,7 +17,7 @@ export default {
     },
 
     create(context) {
-        if (re.manifestFilename.test(file.getName(context))) { // lint it directly
+        if (regex.filename.manifest.test(extension.file.getName(context))) { // lint it directly
             let foundVersion = null, versionNode = null
             return {
                 '*'(node) {
@@ -33,7 +32,7 @@ export default {
                 }
             }
         }
-        const manifest = readManifest(context) ; if (!manifest || manifest.manifest_version == 3) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest || manifest.manifest_version == 3) return {}
         return { Program(node) { context.report({ node, messageId: 'notMV3' }) }}
     }
 }

package/src/rules/require-short-name-when-useful.js

@@ -1,7 +1,8 @@
-import { file } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
 const defaults = { maxNameLength: 12 },
-      re = { i18nPlaceholder: /^__MSG_.+__$/, manifestFilename: /manifest\.json$/ }
+      re = { i18nPlaceholder: /^__MSG_.+__$/ }
 
 function isI18n(value) { return typeof value == 'string' && re.i18nPlaceholder.test(value) }
 
@@ -43,7 +44,7 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
+        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
         const opts = context.options[0] || {},
               maxNameLength = opts.maxNameLength ?? defaults.maxNameLength,
               always = opts.always ?? false,

package/src/rules/valid-filenames.js

@@ -1,9 +1,10 @@
 /* eslint-disable security/detect-non-literal-fs-filename -- lint-time project inspection only */
 
+import extension from '../utils/extension.js'
 import fs from 'node:fs'
 import path from 'node:path'
 
-const re = { invalidChars: /[^\w\-.]/, manifestFilename: /manifest\.json$/, reservedPrefix: /^_/ }
+const re = { invalidChars: /[^\w\-.]/, reservedPrefix: /^_/ }
 
 const refKeys = [
     ['action.default_popup',      manifest => manifest.action?.default_popup],
@@ -15,14 +16,6 @@ const refKeys = [
     ['side_panel.default_path',   manifest => manifest.side_panel?.default_path]
 ]
 
-function findExtensionRoot(startPath) {
-    let dir = path.dirname(startPath)
-    while (dir != path.dirname(dir)) {
-        if (fs.existsSync(path.join(dir, 'manifest.json'))) return dir
-        dir = path.dirname(dir)
-    }
-}
-
 function collectRefs(manifest) {
     const refs = []
     for (const [label, get] of refKeys) {
@@ -115,7 +108,7 @@ export default {
               filename = context.filename
         if (!filename || filename == '<input>') return {}
         const basename = path.basename(filename),
-              extRoot = findExtensionRoot(filename) || path.dirname(filename),
+              extRoot = extension.findRoot(context) || path.dirname(filename),
               segments = path.relative(extRoot, filename).split(path.sep)
         if (noReservedPrefix)
             for (const seg of segments)