eslint-plugin-chrome-extensions 2.4.2 → 2.6.0

package/src/data/permissions.js

@@ -1,31 +1,24 @@
-const re = { url: /^https?:\/\// }
-
-export const sensitivePermissions = new Set([
-    'accessibilityFeatures.modify', 'accessibilityFeatures.read', 'bookmarks', 'browsingData', 'clipboardRead',
-    'contentSettings', 'cookies', 'debugger', 'declarativeNetRequest', 'downloads', 'downloads.open', 'downloads.ui',
-    'geolocation', 'history', 'management', 'nativeMessaging', 'pageCapture', 'privacy', 'proxy', 'readingList',
-    'sessions', 'system.storage', 'tabCapture', 'tabGroups', 'tabs', 'topSites', 'ttsEngine',
-    'webAuthenticationProxy', 'webNavigation', 'webRequest', 'webRequestBlocking'
-])
-
-export const validPermissions = new Set([
-    'accessibilityFeatures.modify', 'accessibilityFeatures.read', 'activeTab', 'alarms', 'audio', 'background',
-    'bookmarks', 'browsingData', 'certificateProvider', 'clipboardRead', 'clipboardWrite', 'contentSettings',
-    'contextMenus', 'cookies', 'debugger', 'declarativeContent', 'declarativeNetRequest',
-    'declarativeNetRequestFeedback', 'declarativeNetRequestWithHostAccess', 'desktopCapture', 'dns', 'documentScan',
-    'downloads', 'downloads.open', 'downloads.ui', 'enterprise.deviceAttributes', 'enterprise.hardwarePlatform',
-    'enterprise.networkingAttributes', 'enterprise.platformKeys', 'favicon', 'fileBrowserHandler',
-    'fileSystemProvider', 'fontSettings', 'gcm', 'geolocation', 'history', 'identity', 'identity.email', 'idle',
-    'loginState', 'management', 'menus', 'nativeMessaging', 'notifications', 'offscreen', 'pageCapture', 'platformKeys',
-    'power', 'printerProvider', 'printing', 'printingMetrics', 'privacy', 'processes', 'proxy', 'publicSuffix',
-    'readingList', 'runtime', 'scripting', 'search', 'sessions', 'sidePanel', 'storage', 'system.cpu',
-    'system.display', 'system.memory', 'system.storage', 'tabCapture', 'tabGroups', 'tabs', 'topSites', 'tts',
-    'ttsEngine', 'unlimitedStorage', 'userScripts', 'vpnProvider', 'wallpaper', 'webAuthenticationProxy',
-    'webNavigation', 'webRequest', 'webRequestBlocking'
-])
-
-export function isValidPermission(name, target = 'mv3') {
-    if (validPermissions.has(name)) return true
-    if (target == 'mv3') return false
-    return re.url.test(name) || name.startsWith('<') || name == '*://*/*'
+export default {
+    sensitive: new Set([
+        'accessibilityFeatures.modify', 'accessibilityFeatures.read', 'bookmarks', 'browsingData', 'clipboardRead',
+        'contentSettings', 'cookies', 'debugger', 'declarativeNetRequest', 'downloads', 'downloads.open',
+        'downloads.ui', 'geolocation', 'history', 'management', 'nativeMessaging', 'pageCapture', 'privacy',
+        'proxy', 'readingList', 'sessions', 'system.storage', 'tabCapture', 'tabGroups', 'tabs', 'topSites',
+        'ttsEngine', 'webAuthenticationProxy', 'webNavigation', 'webRequest', 'webRequestBlocking'
+    ]),
+    valid: new Set([
+        'accessibilityFeatures.modify', 'accessibilityFeatures.read', 'activeTab', 'alarms', 'audio', 'background',
+        'bookmarks', 'browsingData', 'certificateProvider', 'clipboardRead', 'clipboardWrite', 'contentSettings',
+        'contextMenus', 'cookies', 'debugger', 'declarativeContent', 'declarativeNetRequest',
+        'declarativeNetRequestFeedback', 'declarativeNetRequestWithHostAccess', 'desktopCapture', 'dns',
+        'documentScan', 'downloads', 'downloads.open', 'downloads.ui', 'enterprise.deviceAttributes',
+        'enterprise.hardwarePlatform', 'enterprise.networkingAttributes', 'enterprise.platformKeys', 'favicon',
+        'fileBrowserHandler', 'fileSystemProvider', 'fontSettings', 'gcm', 'geolocation', 'history', 'identity',
+        'identity.email', 'idle', 'loginState', 'management', 'menus', 'nativeMessaging', 'notifications',
+        'offscreen', 'pageCapture', 'platformKeys', 'power', 'printerProvider', 'printing', 'printingMetrics',
+        'privacy', 'processes', 'proxy', 'publicSuffix', 'readingList', 'runtime', 'scripting', 'search',
+        'sessions', 'sidePanel', 'storage', 'system.cpu', 'system.display', 'system.memory', 'system.storage',
+        'tabCapture', 'tabGroups', 'tabs', 'topSites', 'tts', 'ttsEngine', 'unlimitedStorage', 'userScripts',
+        'vpnProvider', 'wallpaper', 'webAuthenticationProxy', 'webNavigation', 'webRequest', 'webRequestBlocking'
+    ])
 }

package/src/data/regex.js

@@ -0,0 +1,10 @@
+export default {
+    filename: {
+        css: /\.css$/i,
+        license: // eslint-disable-next-line security/detect-unsafe-regex
+            /^(?:[\w.-]*-)?(?:LICEN[SC]E|COPYING)(?:[-.][\w.-]+)?$/i,
+        manifest: /manifest\.json$/,
+        script: /\.[cm]?[jt]sx?$/i
+    },
+    url: /^https?:\/\//
+}

package/src/index.js

@@ -1,129 +1,12 @@
-import { bundles as oldBundles } from './data/deprecations.js'
+import init from './utils/init.js'
+import deprecations from './data/deprecations.js'
 
-import css from '@eslint/css'
-import html from '@html-eslint/eslint-plugin'
-import json from '@eslint/json'
+const plugin = init.plugin()
 
-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 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 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'
+init.rules(plugin)
+init.configs(plugin)
 
-import { bundle as bundleRules } from './utils/rules.js'
-import { initDeprecation as initBundleDeprecation } from './utils/bundle.js'
-import { textParser } from './data/text-parser.js'
-
-const 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-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-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-chrome-extensions/#${ruleId}`
-
-plugin.configs = {
-    recommended: {
-        plugins: { 'chrome-extensions': plugin },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.recommended, 'chrome-extensions')
-    },
-    strict: {
-        plugins: { 'chrome-extensions': plugin },
-        rules: bundleRules(plugin.rules, () => true, 'chrome-extensions')
-    },
-    problem: {
-        plugins: { 'chrome-extensions': plugin },
-        rules: bundleRules(plugin.rules, rule => rule.meta.type == 'problem', 'chrome-extensions')
-    },
-    security: {
-        plugins: { 'chrome-extensions': plugin },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.security, 'chrome-extensions')
-    },
-    manifest: {
-        language: 'json/json',
-        plugins: { 'chrome-extensions': plugin, json },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.manifest, 'chrome-extensions')
-    },
-    license: {
-        languageOptions: { parser: textParser },
-        plugins: { 'chrome-extensions': plugin },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.license, 'chrome-extensions')
-    },
-    css: {
-        language: 'css/css',
-        plugins: { 'chrome-extensions': plugin, css },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.css, 'chrome-extensions')
-    },
-    html: {
-        language: 'html/html',
-        plugins: { 'chrome-extensions': plugin, html },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.html, 'chrome-extensions')
-    },
-    json: {
-        language: 'json/json',
-        plugins: { 'chrome-extensions': plugin, json },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.json, 'chrome-extensions')
-    },
-    json5: {
-        language: 'json/json5',
-        plugins: { 'chrome-extensions': plugin, json },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.json, 'chrome-extensions')
-    },
-    jsonc: {
-        language: 'json/jsonc',
-        plugins: { 'chrome-extensions': plugin, json },
-        rules: bundleRules(plugin.rules, rule => rule.meta.docs.json, 'chrome-extensions')
-    }
-}
-
-for (const entry of Object.entries(oldBundles))
-    initBundleDeprecation(plugin, entry, 'chrome-extensions')
+for (const entry of Object.entries(deprecations.bundles))
+    init.bundleDeprecation(plugin, entry, 'chrome-extensions')
 
 export { plugin as default, plugin as chromeExtensions }

package/src/rules/manifest-key-order.js

@@ -1,7 +1,7 @@
-import { manifestKeyOrder } from '../data/manifest.js'
-import { file } from '../utils/extension.js'
+import extension from '../utils/extension.js'
 
-const re = { manifestFilename: /manifest\.json$/ }
+import manifest from '../data/manifest.js'
+import regex from '../data/regex.js'
 
 function keyOf(member) {
     const keyNode = member.name || member.key
@@ -43,15 +43,15 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
+        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
         const custom = context.options[0]?.order ?? [],
-              master = custom.length ? manifestKeyOrder.filter(key => !custom.includes(key))
-                     : manifestKeyOrder
+              master = custom.length ? manifest.keys.order.filter(key => !custom.includes(key))
+                     : manifest.keys.order
         return {
             'Document:exit'(document) {
                 const root = document.body ; if (root?.type != 'Object') return
-                const members = root.members || root.properties || []
-                const violation = findViolation(members, master) ?? (custom.length && findViolation(members, custom))
+                const members = root.members || root.properties || [],
+                      violation = findViolation(members, master) ?? (custom.length && findViolation(members, custom))
                 if (!violation) return
                 const [first, second] = violation
                 context.report({

package/src/rules/manifest-spacing.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 = { manifestFilename: /manifest\.json$/, leadingWhitespace: /^[ \t]+/ },
+const re = { leadingWhitespace: /^[ \t]+/ },
       brackets = { open: new Set(['LBrace', 'LBracket']), close: new Set(['RBrace', 'RBracket']) }
 
 export default {
@@ -39,8 +40,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ spaces: 2, checkColons: true, checkCommas: true,
-                           checkBraces: true, checkBrackets: true }],
+        defaultOptions: [{ spaces: 2, checkColons: true, checkCommas: true, checkBraces: true, checkBrackets: true }],
         messages: {
             wrongIndent: 'Expected {{expected}} spaces of indentation (found {{found}}).',
             tabFound: 'Expected spaces for indentation, found tabs.',
@@ -57,7 +57,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] || {},
               spaces = opts.spaces ?? 2,
               checkColons = opts.checkColons ?? true,

package/src/rules/no-content-style-leak.js

@@ -1,4 +1,4 @@
-import { file, readManifest } from '../utils/extension.js'
+import extension from '../utils/extension.js'
 
 const re = { appendMethod: /^append(?:Child)?$/ }
 
@@ -17,7 +17,8 @@ export default {
     },
 
     create(context) {
-        const manifest = readManifest(context) ; if (!manifest || !file.isContentScript(context, manifest)) return {}
+        const manifest = extension.manifest.read(context)
+        if (!manifest || !extension.file.isContentScript(context, manifest)) return {}
         const styleElems = new Set(), docAliases = new Set()
         function isCreateStyle(node) {
             return node?.type == 'CallExpression'
@@ -57,8 +58,9 @@ export default {
             CallExpression(node) {
                 if (node.callee.type != 'MemberExpression') return
                 const method = node.callee.property.name
-                if (!re.appendMethod.test(method)) return
-                if (!isDocumentMember(node.callee.object)) return
+                if (!re.appendMethod.test(method)
+                    || !isDocumentMember(node.callee.object)
+                ) return
                 for (const arg of node.arguments)
                     if (isStyleTarget(arg))
                         context.report({ node: arg, messageId: 'styleLeak' })

package/src/rules/no-deprecated-apis.js

@@ -1,5 +1,5 @@
-import { findDeprecated } from '../data/apis.js'
-import { getMemberPath } from '../utils/node.js'
+import nodeUtils from '../utils/node.js'
+import apis from '../data/apis.js'
 
 export default {
     meta: {
@@ -50,8 +50,8 @@ export default {
         return {
             MemberExpression(node) {
                 if (node.parent.type == 'MemberExpression' && node.parent.object === node) return
-                const api = getMemberPath(node) ; if (!api?.startsWith('chrome.') || isAllowed(api)) return
-                const found = findDeprecated(api) ; if (!found) return
+                const api = nodeUtils.getMemberPath(node) ; if (!api?.startsWith('chrome.') || isAllowed(api)) return
+                const found = apis.findDeprecated(api) ; if (!found) return
                 context.report({ node, messageId: 'deprecatedAPI',
                     data: { api: found.deprecated, replacement: found.replacement, target }})
             }

package/src/rules/no-duplicate-manifest-keys.js

@@ -1,6 +1,5 @@
-import { file } from '../utils/extension.js'
-
-const re = { manifestFilename: /manifest\.json$/ }
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -18,7 +17,7 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
+        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
         return {
             Object(node) {
                 const members = node.members || node.properties || [],

package/src/rules/no-insecure-messaging.js

@@ -1,5 +1,5 @@
-import { getMemberPath } from '../utils/node.js'
-import { isExternalMessagingListener } from '../data/apis.js'
+import nodeUtils from '../utils/node.js'
+import apis from '../data/apis.js'
 
 const re = { postmsgValidation: /\b\w+\.(?:origin|source)\b/, senderValidation: /sender\.(?:id|origin)/ }
 
@@ -44,9 +44,9 @@ export default {
         return {
             CallExpression(node) {
                 if (node.callee.type != 'MemberExpression') return
-                const path = getMemberPath(node.callee) ; if (!path) return
+                const path = nodeUtils.getMemberPath(node.callee) ; if (!path) return
                 const listenerRoot = path.endsWith('.addListener') ? path.slice(0, -'.addListener'.length) : null
-                if (listenerRoot && isExternalMessagingListener(listenerRoot)) {
+                if (listenerRoot && apis.isExternalMsgListener(listenerRoot)) {
                     const handler = node.arguments[0] ; if (!handler) return
                     const body = context.sourceCode.getText(handler)
                     if (!re.senderValidation.test(body))

package/src/rules/no-invalid-locales.js

@@ -0,0 +1,89 @@
+/* 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 i18nUtils from '../utils/i18n.js'
+import path from 'node:path'
+
+import regex from '../data/regex.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow invalid Chrome locale codes in `_locales/` folders and `default_locale`',
+            category: 'Possible Errors',
+            recommended: true,
+            manifest: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedLocales: {
+                    oneOf: [
+                        { type: 'string', description: 'Single locale code to allow' },
+                        {
+                            type: 'array',
+                            items: { type: 'string', description: 'Locale code to allow' },
+                            description: 'List of locale codes to allow'
+                        }
+                    ],
+                    description: 'Additional locale codes to allow (e.g. for Chromium forks)'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{ allowedLocales: [] }],
+        messages: {
+            invalidLocale: '`{{value}}` is not a Chrome-supported locale code.'
+        }
+    },
+
+    create(context) {
+        const filename = extension.file.getName(context),
+              isManifest = regex.filename.manifest.test(filename),
+              isScript = regex.filename.script.test(filename)
+        if (!isManifest && !isScript) return {}
+        const opts = context.options[0] || {},
+              allowed = new Set(Array.isArray(opts.allowedLocales) ? opts.allowedLocales
+                      : opts.allowedLocales ? [opts.allowedLocales] : []),
+              invalidFolders = [],
+              root = extension.findRoot(context)
+        if (root) {
+            const localesDir = path.join(root, '_locales')
+            try {
+                for (const entry of fs.readdirSync(localesDir, { withFileTypes: true }))
+                    if (entry.isDirectory() && isInvalid(entry.name)) invalidFolders.push(entry.name)
+                invalidFolders.sort()
+            } catch {} // eslint-disable-line no-empty
+        }
+        const loc = { line: 1, column: 1 }
+        if (!isManifest) {
+            const manifest = extension.manifest.read(context)
+            if (manifest) {
+                const defaultLocale = manifest.default_locale
+                if (isInvalid(defaultLocale))
+                    context.report({ loc, messageId: 'invalidLocale', data: { value: defaultLocale }})
+            }
+            for (const name of invalidFolders)
+                context.report({ loc, messageId: 'invalidLocale', data: { value: name }})
+            return {}
+        }
+        function isInvalid(locale) {
+            return typeof locale == 'string' && !i18nUtils.localeIsValid(locale, allowed) }
+        return {
+            '*'(node) {
+                const keyNode = node.name || node.key ; if (!keyNode) return
+                const keyName = keyNode.value ?? keyNode.name ; if (keyName != 'default_locale') return
+                const valueNode = node.value ; if (valueNode?.type != 'String') return
+                if (isInvalid(valueNode.value))
+                    context.report({ node: valueNode, messageId: 'invalidLocale',
+                                     data: { value: valueNode.value }})
+            },
+            'Document:exit'() {
+                for (const name of invalidFolders)
+                    context.report({ loc, messageId: 'invalidLocale', data: { value: name }})
+            }
+        }
+    }
+}

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

@@ -1,7 +1,5 @@
-import { file, readManifest } from '../utils/extension.js'
-import { isValidPermission } from '../data/permissions.js'
-
-const re = { manifestFilename: /manifest\.json$/ }
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -9,7 +7,7 @@ export default {
         docs: {
             description: 'Disallow invalid or unsupported manifest permission names',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         defaultOptions: [{ target: 'mv3', allowedPermissions: [] }],
@@ -46,29 +44,28 @@ export default {
                       : opts.allowedPermissions ? [opts.allowedPermissions] : [])
         function checkPermission(node, permission) {
             if (typeof permission != 'string') return
-            if (allowed.has(permission) || isValidPermission(permission, target)) return
+            if (allowed.has(permission) || extension.manifest.permission.isValid(permission, target)) return
             context.report({ node, messageId: 'invalidPermission', data: { permission, target }})
         }
-        if (re.manifestFilename.test(file.getName(context))) // lint it directly
+        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
+                    if (!['optional_permissions', 'permissions'].includes(keyNode.value ?? keyNode.name)) return
                     const arrNode = node.value ; if (arrNode?.type != 'Array') return
-                    const elems = arrNode.elements || arrNode.items || []
-                    for (const elem of elems) {
+                    const nodeElems = arrNode.elements || arrNode.items || []
+                    for (const elem of nodeElems) {
                         const valueNode = elem.value || elem
                         checkPermission(valueNode, valueNode?.value)
                     }
                 }
             }
-        const manifest = readManifest(context) ; if (!manifest) return {}
+        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) || isValidPermission(permission, target)) continue
+                    if (allowed.has(permission) || extension.manifest.permission.isValid(permission, target)) continue
                     context.report({ loc: { line: 1, column: 0 },
                         messageId: 'invalidPermission', data: { permission, target }})
                 }

package/src/rules/no-missing-default-locale.js

@@ -1,12 +1,19 @@
 /* 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 i18n from '../utils/i18n.js'
 import path from 'node:path'
 
-import { findExtensionRoot, isPredefined } from '../data/i18n.js'
-import { readManifest } from '../utils/extension.js'
+import regex from '../data/regex.js'
 
-const re = { manifestFile: /manifest\.json$/ }
+function readLocaleDirs(localesDir)  {
+    try {
+        return fs.readdirSync(localesDir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name)
+    } catch { return [] }
+}
 
 function readMessages(filePath) {
     try {
@@ -15,21 +22,13 @@ function readMessages(filePath) {
     } catch { return null }
 }
 
-function readLocaleDirs(localesDir) {
-    try {
-        return fs.readdirSync(localesDir, { withFileTypes: true })
-            .filter(entry => entry.isDirectory())
-            .map(entry => entry.name)
-    } catch { return [] }
-}
-
 export default {
     meta: {
         type: 'problem',
         docs: {
             description: 'Ensure `default_locale` is valid and all `_locales` keys exist in it',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [{
@@ -37,31 +36,37 @@ export default {
             properties: {
                 ignoreKeys: {
                     type: 'array', items: { type: 'string' },
-                    description: 'Keys to skip when checking the default locale'
+                    description: 'Keys to skip when checking locales'
+                },
+                checkAllLocales: {
+                    type: 'boolean',
+                    description: 'Also flag keys missing from any locale, not just the default'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ ignoreKeys: [] }],
+        defaultOptions: [{ ignoreKeys: [], checkAllLocales: false }],
         messages: {
             missingDefaultLocale: '`_locales/` exists but `default_locale` is not declared.',
             unexpectedDefaultLocale: '`default_locale` is declared but no `_locales/` directory exists.',
             missingDefaultLocaleFile: '`_locales/{{locale}}/messages.json` does not exist.',
             missingKeyInDefault: '`{{key}}` exists in `_locales/{{locale}}/messages.json`, '
-                               + 'but not in default locale `{{defaultLocale}}`.'
+                               + 'but not in default locale `{{defaultLocale}}`.',
+            missingKeyInLocale: '`{{key}}` is missing from `_locales/{{locale}}/messages.json`.'
         }
     },
 
     create(context) {
-        const filename = context.filename
-        if (!filename || !re.manifestFile.test(filename)) return {}
-        const manifest = readManifest(context) ; if (!manifest) return {}
-        const root = findExtensionRoot(filename) ; if (!root) return {}
+        const filename = extension.file.getName(context) ; if (!filename) return {}
+        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 localesDir = path.join(root, '_locales'),
               hasLocales = fs.existsSync(localesDir),
               defaultLocale = manifest.default_locale,
               opts = context.options[0] || {},
               ignored = new Set(opts.ignoreKeys || []),
+              checkAllLocales = opts.checkAllLocales ?? false,
               loc = { line: 1, column: 1 }
         if (hasLocales && typeof defaultLocale != 'string') {
             context.report({ loc, messageId: 'missingDefaultLocale' })
@@ -77,11 +82,29 @@ export default {
             context.report({ loc, messageId: 'missingDefaultLocaleFile', data: { locale: defaultLocale }})
             return {}
         }
-        for (const locale of readLocaleDirs(localesDir)) {
+        const localeDirs = readLocaleDirs(localesDir)
+        if (checkAllLocales) {
+            const allMsgs = new Map([[defaultLocale, defaultMsgs]])
+            for (const locale of localeDirs) {
+                if (locale == defaultLocale) continue
+                const msgs = readMessages(path.join(localesDir, locale, 'messages.json'))
+                if (msgs) allMsgs.set(locale, msgs)
+            }
+            const union = new Set()
+            for (const msgs of allMsgs.values())
+                for (const key of Object.keys(msgs))
+                    if (!i18n.isPredefined(key) && !ignored.has(key)) union.add(key)
+            for (const [locale, msgs] of allMsgs)
+                for (const key of union)
+                    if (!(key in msgs))
+                        context.report({ loc, messageId: 'missingKeyInLocale', data: { key, locale }})
+            return {}
+        }
+        for (const locale of localeDirs) {
             if (locale == defaultLocale) continue
             const msgs = readMessages(path.join(localesDir, locale, 'messages.json')) ; if (!msgs) continue
             for (const key of Object.keys(msgs)) {
-                if (isPredefined(key) || ignored.has(key)) continue
+                if (i18n.isPredefined(key) || ignored.has(key)) continue
                 if (!(key in defaultMsgs))
                     context.report({ loc, messageId: 'missingKeyInDefault', data: { key, locale, defaultLocale }})
             }