eslint-plugin-chrome-extensions 2.8.0 → 2.9.0

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

@@ -4,6 +4,8 @@ import i18nUtils from '../utils/i18n.js'
 import i18nData from '../data/i18n.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = { ignoreKeys: [], scanExtensions: i18nData.defaultScanExtensions }
+
 export default {
     meta: {
         type: 'suggestion',
@@ -26,7 +28,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ ignoreKeys: [], scanExtensions: i18nData.defaultScanExtensions }],
+        defaultOptions: [defaultOptions],
         messages: {
             unusedKey: '`{{key}}` in `_locales/{{locale}}/messages.json` is never referenced.'
         }
@@ -38,9 +40,8 @@ export default {
         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 || i18nData.defaultScanExtensions
+        const { ignoreKeys, scanExtensions } = { ...defaultOptions, ...context.options[0] },
+                ignored = new Set(ignoreKeys)
         function check() {
             const { used, patterns } = i18nUtils.collectUsedKeys(root, scanExtensions)
             for (const key of Object.keys(i18n.messages)) {

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

@@ -1,7 +1,7 @@
 import extension from '../utils/extension.js'
 import regex from '../data/regex.js'
 
-const defaults = { maxNameLength: 12 },
+const defaultOptions = { maxNameLength: 12, always: false, checkRedundant: false },
       re = { i18nPlaceholder: /^__MSG_.+__$/ }
 
 function isI18n(value) { return typeof value == 'string' && re.i18nPlaceholder.test(value) }
@@ -32,9 +32,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{
-            maxNameLength: defaults.maxNameLength, always: false, checkRedundant: false
-        }],
+        defaultOptions: [defaultOptions],
         messages: {
             missingShortName: '`name` exceeds {{max}} chars. Declare `short_name` to control truncation.',
             shortNameTooLong: '`short_name` exceeds the recommended {{max}}-character limit (found {{length}}).',
@@ -44,10 +42,7 @@ export default {
 
     create(context) {
         if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
-        const opts = context.options[0] || {},
-              maxNameLength = opts.maxNameLength ?? defaults.maxNameLength,
-              always = opts.always ?? false,
-              checkRedundant = opts.checkRedundant ?? false
+        const { maxNameLength, always, checkRedundant } = { ...defaultOptions, ...context.options[0] }
         let manifest
         try { manifest = JSON.parse(context.sourceCode.text) } catch { return {} }
         if (!manifest || typeof manifest != 'object') return {}

package/src/rules/valid-filenames.js

@@ -4,6 +4,11 @@ import extension from '../utils/extension.js'
 import fs from 'node:fs'
 import path from 'node:path'
 
+const defaultOptions = {
+    noReservedPrefix: true, noSpecialChars: true, checkFileExists: true, enforceCaseSensitivity: true,
+    maxFullPathLength: 260
+}
+
 const re = { invalidChars: /[^\w\-.]/ }
 
 const refKeys = [
@@ -85,10 +90,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{
-            noReservedPrefix: true, noSpecialChars: true, checkFileExists: true, enforceCaseSensitivity: true,
-            maxFullPathLength: 260
-        }],
+        defaultOptions: [defaultOptions],
         messages: {
             reservedPrefix: '`{{name}}` starts with reserved prefix `_` (only `_locales` is allowed).',
             specialChars: '`{{name}}` contains characters outside `a-z`, `0-9`, `-`, `_`, and `.`.',
@@ -99,13 +101,9 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] || {},
-              noReservedPrefix = opts.noReservedPrefix ?? true,
-              noSpecialChars = opts.noSpecialChars ?? true,
-              checkFileExists = opts.checkFileExists ?? true,
-              enforceCaseSensitivity = opts.enforceCaseSensitivity ?? true,
-              maxFullPathLength = opts.maxFullPathLength ?? 260,
-              filename = context.filename
+        const { noReservedPrefix, noSpecialChars, checkFileExists, enforceCaseSensitivity, maxFullPathLength }
+            = { ...defaultOptions, ...context.options[0] }
+        const { filename } = context
         if (!filename || filename == '<input>') return {}
         const basename = path.basename(filename),
               extRoot = extension.findRoot(context) || path.dirname(filename),

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

@@ -4,6 +4,8 @@ import path from 'node:path'
 
 import regex from '../data/regex.js'
 
+const defaultOptions = { requireSPDX: false, allowedLicenses: [] }
+
 function validateContent(context, node, { requireSPDX, allowedLicenses }) {
     const text = context.sourceCode.text,
           id = license.spdx.parse(text)
@@ -29,7 +31,7 @@ export default {
             description: 'Validates SPDX identifiers in license files',
             license: true
         },
-        defaultOptions: [{ requireSPDX: false, allowedLicenses: [] }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -52,11 +54,10 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0],
-            { requireSPDX } = opts,
-              allowedLicenses = array.to(opts.allowedLicenses),
-            { filename } = context,
-              basename = path.basename(filename)
+        const { requireSPDX, allowedLicenses: rawAllowedLicenses } = { ...defaultOptions, ...context.options[0] },
+                allowedLicenses = array.to(rawAllowedLicenses),
+              { filename } = context,
+                basename = path.basename(filename)
         if (!regex.filename.license.test(basename) || regex.filename.script.test(basename))
             return {}
         return { Program: node => validateContent(context, node, { requireSPDX, allowedLicenses })}

package/src/rules/valid-manifest-icons.js

@@ -4,13 +4,14 @@ import path from 'node:path'
 
 import regex from '../data/regex.js'
 
-const re = { svg: /\.svg$/i },
+const defaultOptions = { requireRecommendedSizes: true, checkIconExists: true, noSVG: true },
+      re = { svg: /\.svg$/i },
       sizes = { recommended: ['16', '32', '48', '128'], required: '128' }
 
-function validateIcons(context, icons, root, opts, loc) {
-    const { requireRecommended, checkFiles, checkSVG } = opts,
+function validateIcons(context, icons, root, options, loc) {
+    const { requireRecommendedSizes, checkIconExists, noSVG } = options,
             declaredSizes = new Set(Object.keys(icons))
-    if (requireRecommended) {
+    if (requireRecommendedSizes) {
         for (const size of sizes.recommended)
             if (!declaredSizes.has(size))
                 context.report({ loc, messageId: 'missingSize', data: { size }})
@@ -18,9 +19,9 @@ function validateIcons(context, icons, root, opts, loc) {
         context.report({ loc, messageId: 'missingRequiredSize' })
     for (const file of Object.values(icons)) {
         if (typeof file != 'string') continue
-        if (checkSVG && re.svg.test(file))
+        if (noSVG && re.svg.test(file))
             context.report({ loc, messageId: 'svgNotSupported' })
-        else if (checkFiles && root // oxlint-disable-next-line security/detect-non-literal-fs-filename
+        else if (checkIconExists && root // oxlint-disable-next-line security/detect-non-literal-fs-filename
             && !fs.existsSync(path.resolve(root, file))
         ) context.report({ loc, messageId: 'missingFile', data: { file }})
     }
@@ -35,11 +36,7 @@ export default {
             recommended: true,
             manifest: true
         },
-        defaultOptions: [{
-            requireRecommendedSizes: true,
-            checkIconExists: true,
-            noSVG: true
-        }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -69,12 +66,9 @@ export default {
     create(context) {
         const filename = extension.file.getName(context)
         if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
-        const opts = context.options[0] || {},
-              requireRecommended = opts.requireRecommendedSizes !== false,
-              checkFiles = opts.checkIconExists !== false,
-              checkSVG = opts.noSVG !== false,
-              root = checkFiles ? extension.findRoot(context) : null,
-              resolved = { requireRecommended, checkFiles, checkSVG }
+        const { requireRecommendedSizes, checkIconExists, noSVG } = { ...defaultOptions, ...context.options[0] },
+                root = checkIconExists ? extension.findRoot(context) : null,
+                resolved = { requireRecommendedSizes, checkIconExists, noSVG }
         if (!regex.filename.manifest.test(filename)) {
             const manifest = extension.manifest.read(context) ; if (!manifest) return {}
             const icons = manifest.icons
@@ -96,13 +90,13 @@ export default {
                           file = fileNode?.value
                     if (typeof size == 'string') declaredSizes.add(size)
                     if (typeof file != 'string') continue
-                    if (checkSVG && re.svg.test(file))
+                    if (noSVG && re.svg.test(file))
                         context.report({ node: fileNode, messageId: 'svgNotSupported' })
-                    else if (checkFiles && root // oxlint-disable-next-line security/detect-non-literal-fs-filename
+                    else if (checkIconExists && root // oxlint-disable-next-line security/detect-non-literal-fs-filename
                         && !fs.existsSync(path.resolve(root, file))
                     ) context.report({ node: fileNode, messageId: 'missingFile', data: { file }})
                 }
-                if (requireRecommended) {
+                if (requireRecommendedSizes) {
                     for (const size of sizes.recommended)
                         if (!declaredSizes.has(size))
                             context.report({ node: iconsObj, messageId: 'missingSize', data: { size }})

package/src/rules/valid-service-worker.js

@@ -3,6 +3,8 @@ import nodeUtils from '../utils/node.js'
 
 import manifestData from '../data/manifest.js'
 
+const defaultOptions = { checkListenerTopLevel: true, checkKeepaliveTimer: true, checkDOMglobals: true }
+
 export default {
     meta: {
         type: 'problem',
@@ -23,11 +25,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{
-            checkListenerTopLevel: true,
-            checkKeepaliveTimer: true,
-            checkDOMglobals: true
-        }],
+        defaultOptions: [defaultOptions],
         messages: {
             listenerNotTopLevel: '`chrome.*.addListener()` must be registered at module top level'
                                + ' so it attaches on service worker wake-up.',
@@ -37,8 +35,9 @@ export default {
     },
 
     create(context) {
-        const { checkListenerTopLevel, checkKeepaliveTimer, checkDOMglobals } = context.options[0],
-                manifest = extension.manifest.read(context)
+        const { checkListenerTopLevel, checkKeepaliveTimer, checkDOMglobals }
+            = { ...defaultOptions, ...context.options[0] }
+        const manifest = extension.manifest.read(context)
         if (!manifest || !extension.file.isServiceWorker(context, manifest)) return {}
         return {
             CallExpression(node) {
@@ -50,9 +49,8 @@ export default {
                 if (checkKeepaliveTimer
                     && node.callee.type == 'Identifier'
                     && ['setTimeout', 'setInterval'].includes(node.callee.name)
-                    && node.arguments[1]?.type == 'Literal'
-                    && typeof node.arguments[1].value == 'number'
-                    && node.arguments[1].value < 30000
+                    && nodeUtils.getNumberLiteral(node.arguments[1]) !== null
+                    && nodeUtils.getNumberLiteral(node.arguments[1]) < 30000
                     && !nodeUtils.isInsideNestedFunction(node)
                 ) context.report({ node, messageId: 'keepaliveTimer', data: { fn: node.callee.name }})
             },

package/src/rules/valid-url-fields.js

@@ -3,6 +3,9 @@ import extension from '../utils/extension.js'
 import manifestData from '../data/manifest.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = {
+    checkURLfields: true, checkMatchPatterns: true, allowedSchemes: ['https', 'file'], allowAllURLs: false }
+
 const re = {
     absoluteURL: /^[a-z][a-z0-9+.-]*:\/\/[^\s/]+/i,
     match: /^(\*|https?|file|ftp):\/\/([^/]*)(\/.*)$/,
@@ -86,10 +89,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{
-            checkURLfields: true, checkMatchPatterns: true,
-            allowedSchemes: ['https', 'file'], allowAllURLs: false
-        }],
+        defaultOptions: [defaultOptions],
         messages: {
             invalidURL: '`{{field}}` has an invalid URL: "{{value}}".',
             invalidMatchPattern: '`{{field}}` has an invalid match pattern: "{{value}}".',
@@ -105,23 +105,18 @@ export default {
     create(context) {
         const filename = extension.file.getName(context)
         if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
-        const opts = context.options[0] || {},
-              checkURLfields = opts.checkURLfields ?? true,
-              checkMatchPatterns = opts.checkMatchPatterns ?? true,
-              allowedSchemes = opts.allowedSchemes ?? ['https', 'file'],
-              allowAllURLs = opts.allowAllURLs ?? false
-        if (!checkURLfields && !checkMatchPatterns) return {}
-        const resolved = { checkURLfields, checkMatchPatterns, allowedSchemes, allowAllURLs }
+        const options = { ...defaultOptions, ...context.options[0] }
+        if (!options.checkURLfields && !options.checkMatchPatterns) return {}
         if (!regex.filename.manifest.test(filename)) {
             const manifest = extension.manifest.read(context) ; if (!manifest) return {}
-            validateManifest(context, manifest, resolved)
+            validateManifest(context, manifest, options)
             return {}
         }
         return {
             'Document:exit'() {
                 let manifest
                 try { manifest = JSON.parse(context.sourceCode.text) } catch { return }
-                validateManifest(context, manifest, resolved)
+                validateManifest(context, manifest, options)
             }
         }
     }

package/src/rules/valid-version-field.js

@@ -1,6 +1,8 @@
 import extension from '../utils/extension.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = { versionType: 'chrome', allowFutureDate: false }
+
 const re = { // oxlint-disable security/detect-unsafe-regex
     chromeParts: /^\d+(?:\.\d+){0,3}$/,
     date: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
@@ -36,7 +38,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{}],
+        defaultOptions: [defaultOptions],
         messages: {
             invalidVersion: 'Invalid manifest `version`: must be a valid {{versionType}} version '
                           + '(expected format: {{example}}).',
@@ -45,11 +47,8 @@ export default {
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              versionType = options.versionType || 'chrome',
-              allowFutureDate = options.allowFutureDate ?? false,
-              timezone = options.timezone,
-              example = versionType == 'semver' ? '1.2.3'
+        const { versionType, allowFutureDate, timezone } = { ...defaultOptions, ...context.options[0] }
+        const example = versionType == 'semver' ? '1.2.3'
                       : versionType == 'date' ? 'YYYY.M.D or YYYY.M.D.N'
                       : '1.2.3 or 1.2.3.4'
         const now = timezone

package/src/utils/extension.js

@@ -8,6 +8,9 @@ import regex from '../data/regex.js'
 
 const manifestCache = new Map()
 
+function stripScriptExt(filePath) { return filePath.replace(regex.filename.script, '') }
+function sameScriptPath(a, b) { return a === b || stripScriptExt(a) === stripScriptExt(b) }
+
 const utils = {
     file: {
         getName(context) { return context.filename || context.getFilename() },
@@ -17,13 +20,14 @@ const utils = {
             if (!scripts.length) return false
             const root = utils.findRoot(context) ; if (!root) return false
             const filename = path.resolve(utils.file.getName(context))
-            return scripts.some(script => filename == path.resolve(root, script))
+            return scripts.some(script => sameScriptPath(filename, path.resolve(root, script)))
         },
 
         isServiceWorker(context, manifest) {
-            const worker = manifest?.background?.service_worker ; if (!worker) return false
+            const worker = manifest?.background?.service_worker
+            if (!worker) return false
             const root = utils.findRoot(context) ; if (!root) return false
-            return path.resolve(utils.file.getName(context)) == path.resolve(root, worker)
+            return sameScriptPath(path.resolve(utils.file.getName(context)), path.resolve(root, worker))
         }
     },
 

package/src/utils/init.js

@@ -4,6 +4,7 @@ import json from '@eslint/json'
 import pkg from './pkg.js'
 import rulesUtils from './rules.js'
 import text from './text.js'
+import tsParser from '@typescript-eslint/parser'
 
 import cssSpacing from '../rules/css-spacing.js'
 import manifestKeyOrder from '../rules/manifest-key-order.js'
@@ -51,10 +52,10 @@ export default {
               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),
+            recommended: { ...createConfig(rule => rule.meta.docs.recommended), languageOptions: { parser: tsParser }},
+            strict: { ...createConfig(() => true), languageOptions: { parser: tsParser }},
+            problem: { ...createConfig(rule => rule.meta.type == 'problem'), languageOptions: { parser: tsParser }},
+            security: { ...createConfig(rule => rule.meta.docs.security), languageOptions: { parser: tsParser }},
             manifest: {
                 ...createConfig(rule => rule.meta.docs.manifest), language: 'json/json', plugins: { ...plugins, json }},
             license: {

package/src/utils/node.js

@@ -1,4 +1,9 @@
 export default {
+    getLiteral(node) {
+        const inner = this.unwrapTS(node)
+        return inner?.type == 'Literal' ? inner : null
+    },
+
     getMemberPath(node) {
         const parts = [] ; let currentNode = node
         while (currentNode?.type == 'MemberExpression') {
@@ -11,6 +16,16 @@ export default {
         return parts.join('.')
     },
 
+    getNumberLiteral(node) {
+        const literal = this.getLiteral(node)
+        return typeof literal?.value == 'number' ? literal.value : null
+    },
+
+    getStringLiteral(node) {
+        const literal = this.getLiteral(node)
+        return typeof literal?.value == 'string' ? literal.value : null
+    },
+
     isInsideNestedFunction(node) {
         let ancestor = node.parent
         while (ancestor) {
@@ -21,5 +36,12 @@ export default {
         return false
     },
 
-    plainType(node, prefix) { return node?.type?.replace(prefix, '') ?? '' }
+    plainType(node, prefix) { return node?.type?.replace(prefix, '') ?? '' },
+
+    unwrapTS(node) {
+        while (node
+            && ['TSAsExpression', 'TSTypeAssertion', 'TSNonNullExpression', 'TSSatisfiesExpression'].includes(node.type)
+        ) node = node.expression
+        return node
+    }
 }