eslint-plugin-greasemonkey 1.10.1 → 1.10.2

package/README.md

@@ -7,7 +7,7 @@
 <a href="https://codeberg.org/adamlui/eslint-plugin-greasemonkey/src/branch/main/docs/LICENSE.md">
     <img alt="[License: MIT]" src="https://img.shields.io/badge/License-MIT-f1f20a.svg?logo=internetarchive&logoColor=white&labelColor=464646&style=for-the-badge"></a>
 <a target="_blank" href="https://getnpmstats.com/?package=eslint-plugin-greasemonkey&range=last-year&interval=monthly">
-    <img src="https://img.shields.io/npm/dm/eslint-plugin-greasemonkey?style=for-the-badge&logo=npm&color=black"></a>
+    <img alt="[Monthly npm downloads]" src="https://img.shields.io/npm/dm/eslint-plugin-greasemonkey?style=for-the-badge&logo=npm&color=black"></a>
 <a href="#usage">
     <img alt="[Supports ESLint >=9.0.0 / Oxlint >=1.65.0]" src="https://img.shields.io/badge/Supports-ESLint_%3E%3D9.0.0_%2F_Oxlint_%3E%3D1.65.0-4B32C3?style=for-the-badge&logo=eslint"></a>
 <br><br>
@@ -44,7 +44,7 @@ import greasemonkey from 'eslint-plugin-greasemonkey'
 export default [
     // other configs
     {
-        files: ['**/*.user.js'], plugins: { greasemonkey }
+        files: ['**/*.user.js'], plugins: { greasemonkey },
         rules: {
             ...greasemonkey.configs.recommended.rules,
             'greasemonkey/no-unused-resources': 'off',  // selectively disable rule
@@ -60,7 +60,7 @@ export default [
 
 ### <img height=15 width=auto src="https://www.google.com/s2/favicons?domain=oxc.rs&sz=64"> Oxlint
 
-Add a bundled config to your `oxlint.config.ts`:
+Add a bundled config to your `oxlint.config.*ts`:
 
 ```ts
 ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-greasemonkey",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "description": "ESLint rules for Greasemonkey/Tampermonkey userscripts",
   "keywords": [
     "eslint",
@@ -69,20 +69,22 @@
     "@eslint/json": "^2.1.1",
     "@eslint/markdown": "^7.5.1",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "eslint": "^10.13.0",
-    "eslint-plugin-constructors": "^1.5.1",
+    "eslint": "^10.14.0",
+    "eslint-plugin-constructors": "^1.7.0",
     "eslint-plugin-eslint-plugin": "^7.6.2",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-n": "^18.5.0",
     "eslint-plugin-no-secrets": "^2.3.3",
     "eslint-plugin-no-unsanitized": "^4.1.5",
-    "eslint-plugin-package-json": "^1.11.0",
+    "eslint-plugin-package-json": "^1.12.0",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-regexp": "^3.3.1",
-    "eslint-plugin-security": "^4.2.0",
+    "eslint-plugin-regexp": "^3.3.2",
+    "eslint-plugin-security": "^4.2.1",
     "eslint-plugin-sonarjs": "^4.2.2",
-    "eslint-plugin-woodpecker": "^1.1.1",
-    "oxlint": "^1.89.0"
+    "eslint-plugin-woodpecker": "^1.1.2",
+    "oxlint": "^1.90.0",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "typescript-latest": "npm:typescript@^7.0.2"
   },
   "peerDependencies": {
     "eslint": ">=9.0.0"

package/src/rules/meta-order.js

@@ -1,5 +1,6 @@
 import metadata from '../utils/metadata.js'
 
+const defaultOptions = { order: [] }
 const defaultOrder = [
     'name', 'description', 'author', 'namespace', 'version', 'license', 'icon', 'icon64',
     'compatible', 'match', 'exclude', 'include', 'connect', 'require', 'resource', 'grant',
@@ -43,21 +44,21 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ order: [] }],
+        defaultOptions: [defaultOptions],
         messages: { wrongOrder: '@{{first}} should appear before @{{second}}.' }
     },
 
     create(context) {
-        const custom = context.options[0]?.order ?? [],
-              master = custom.length ? defaultOrder.filter(key => !custom.includes(key)) : defaultOrder
+        const { order } = { ...defaultOptions, ...context.options[0] },
+                master = order.length ? defaultOrder.filter(key => !order.includes(key)) : defaultOrder
         return {
             Program() {
                 const sourceCode = context.sourceCode,
                       entries = metadata.extract(sourceCode),
-                      violation = findViolation(entries, master) ?? (custom.length && findViolation(entries, custom))
+                      violation = findViolation(entries, master) ?? (order.length && findViolation(entries, order))
                 if (!violation) return
                 const [first, second] = violation
-                const sorted = sortEntries(sortEntries(entries, master), custom)
+                const sorted = sortEntries(sortEntries(entries, master), order)
                 const replacements = // oxlint-disable-next-line security/detect-object-injection
                     new Map(sorted.map((entry, idx) => [entries[idx], sourceCode.getText(entry.comment)]))
                 const start = entries[0].comment.range[0]

package/src/rules/meta-spacing.js

@@ -1,6 +1,8 @@
 import metadata from '../utils/metadata.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = { spaces: 3 }
+
 export default {
     meta: {
         type: 'layout',
@@ -15,27 +17,27 @@ export default {
             properties: {
                 spaces: {
                     type: 'number',
-                    description: 'Minimum spaces after the longest key (default 3)'
+                    description: 'Minimum spaces after the longest key'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ spaces: 3 }],
+        defaultOptions: [defaultOptions],
         messages: { misaligned: 'Metadata values should be aligned at column {{column}}.' }
     },
 
     create(context) {
-        const minSpaces = context.options[0]?.spaces ?? 3
+        const { spaces } = { ...defaultOptions, ...context.options[0] }
         return {
             Program() {
                 const sourceCode = context.sourceCode,
                       metaEntries = metadata.extract(sourceCode)
                 if (!metaEntries.length) return
-                let targetCol = metaEntries.reduce((max, entry) => Math.max(max, entry.key.length), 0) + minSpaces +4
+                let targetCol = metaEntries.reduce((max, entry) => Math.max(max, entry.key.length), 0) + spaces +4
                 for (const entry of metaEntries)
                     if (entry.key == 'resource' && entry.value.trim()) {
                         const name = entry.value.trim().split(regex.whitespace.all)[0],
-                              requiredCol = 4 + entry.key.length +1 + name.length + minSpaces
+                              requiredCol = 4 + entry.key.length +1 + name.length + spaces
                         if (requiredCol > targetCol) targetCol = requiredCol
                     }
                 for (const entry of metaEntries) {

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

@@ -1,3 +1,4 @@
+const defaultOptions = { disallowWildcardTarget: true }
 const re = {
     messageTargets: new Set(['window', 'self', 'unsafeWindow']),
     postmsgValidation: /\b\w+\.(?:origin|source)\b/
@@ -14,7 +15,7 @@ export default {
             recommended: true,
             security: true
         },
-        defaultOptions: [{ disallowWildcardTarget: true }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -34,9 +35,8 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] || {},
-              disallowWildcard = opts.disallowWildcardTarget !== false,
-              sourceCode = context.sourceCode ?? context.getSourceCode()
+        const { disallowWildcardTarget } = { ...defaultOptions, ...context.options[0] },
+                sourceCode = context.sourceCode ?? context.getSourceCode()
         function checkPostMessageHandler(node, handlerNode, target) {
             if (!handlerNode) return
             const body = sourceCode.getText(handlerNode)
@@ -50,7 +50,7 @@ export default {
                     && node.arguments[0]?.value == 'message'
                     && isMessageTarget(node.callee.object)
                 ) checkPostMessageHandler(node, node.arguments[1], node.callee.object.name)
-                if (disallowWildcard && node.callee.property?.name == 'postMessage') {
+                if (disallowWildcardTarget && node.callee.property?.name == 'postMessage') {
                     const target = node.arguments[1]
                     if (target?.type == 'Literal' && target.value == '*')
                         context.report({ node: target, messageId: 'wildcardTarget' })

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

@@ -4,7 +4,8 @@ import metadata from '../utils/metadata.js'
 import apis from '../data/apis.js'
 import headers from '../data/headers.js'
 
-const specialGrants = new Set(['none', 'unsafeWindow', 'window.close', 'window.focus', 'window.onurlchange']),
+const defaultOptions = { target: 'all', allowedGrants: [] },
+      specialGrants = new Set(['none', 'unsafeWindow', 'window.close', 'window.focus', 'window.onurlchange']),
       allGrants = new Set([...apis.all, ...specialGrants]),
       sortedGrants = new Map(Array.from(allGrants, grant => [grant.toLowerCase(), grant]))
 
@@ -23,21 +24,21 @@ export default {
                     anyOf: [
                         { type: 'string', enum: ['all', ...headers.managers] },
                         { type: 'array', items: { type: 'string', enum: headers.managers },
-                            minItems: 1, uniqueItems: true }
+                            uniqueItems: true }
                     ],
                     description: 'Manager(s) whose grants to validate against (default: all)'
                 },
                 allowedGrants: {
                     anyOf: [
                         { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1, uniqueItems: true }
+                        { type: 'array', items: { type: 'string' }, uniqueItems: true }
                     ],
                     description: 'Additional @grant values to allow beyond the built-in list'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{}],
+        defaultOptions: [defaultOptions],
         messages: {
             invalidGrant: 'Invalid @grant: "{{grant}}"',
             unsupportedGrant: '"@{{grant}}" is not supported by {{target}} (only by {{supporting}}).',
@@ -46,18 +47,16 @@ export default {
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              rawTarget = options.target ?? 'all',
-              targets = Array.isArray(rawTarget) ? rawTarget : [rawTarget],
-              rawAllowed = options.allowedGrants ?? [],
-              allowedGrants = new Set(Array.isArray(rawAllowed) ? rawAllowed : [rawAllowed])
+        const { target, allowedGrants } = { ...defaultOptions, ...context.options[0] },
+                targets = Array.isArray(target) ? target : [target],
+                allowedGrantSet = new Set(Array.isArray(allowedGrants) ? allowedGrants : [allowedGrants])
         return {
             Program() {
                 const metaEntries = metadata.extract(context.sourceCode),
                       grantEntries = metaEntries.filter(entry => entry.key == 'grant')
                 for (const grant of grantEntries) {
                     const grantName = grant.value.trim()
-                    if (specialGrants.has(grantName) || allowedGrants.has(grantName)) continue
+                    if (specialGrants.has(grantName) || allowedGrantSet.has(grantName)) continue
                     if (!allGrants.has(grantName)) {
                         const suggestion = sortedGrants.get(grantName.toLowerCase())
                         if (suggestion && suggestion != grantName)

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

@@ -1,6 +1,8 @@
 import metadata from '../utils/metadata.js'
 import headers from '../data/headers.js'
 
+const defaultOptions = { target: 'all', allowedHeaders: [] }
+
 function parseAllowedPattern(entry) {
     if (typeof entry != 'string' || !entry.startsWith('/')) return null
     const lastSlash = entry.lastIndexOf('/')
@@ -36,7 +38,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ allowedHeaders: [] }],
+        defaultOptions: [defaultOptions],
         messages: {
             invalidHeader: 'Invalid header: "@{{header}}".',
             unsupportedHeader: '"@{{header}}" is not supported by {{target}} (only by {{supporting}}).'
@@ -44,14 +46,13 @@ export default {
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              rawTarget = options.target ?? 'all',
-              targets = Array.isArray(rawTarget) ? rawTarget : [rawTarget],
-              allowedList = [options.allowedHeaders ?? []].flat(),
-              allowedExact = new Set(),
-              allowedRegexes = [],
-              validSet = targets.includes('all') ? headers.valid.get('all')
-                       : new Set(targets.flatMap(target => [...headers.valid.get(target)]))
+        const { target, allowedHeaders } = { ...defaultOptions, ...context.options[0] },
+                targets = Array.isArray(target) ? target : [target],
+                allowedList = [allowedHeaders].flat(),
+                allowedExact = new Set(),
+                allowedRegexes = [],
+                validSet = targets.includes('all') ? headers.valid.get('all')
+                         : new Set(targets.flatMap(target => [...headers.valid.get(target)]))
         for (const entry of allowedList) {
             if (entry instanceof RegExp) allowedRegexes.push(entry)
             else if (typeof entry == 'string') {

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

@@ -2,7 +2,8 @@ import apis from '../data/apis.js'
 import headers from '../data/headers.js'
 import regex from '../data/regex.js'
 
-const re = { connect: /^\s*\/\/\s*@connect\s+(\S+)/, grant: /^\s*\/\/\s*@grant\s+(\S+)/ }
+const defaultOptions = { target: 'all', allowedGrants: [], allowBroadConnect: false },
+      re = { connect: /^\s*\/\/\s*@connect\s+(\S+)/, grant: /^\s*\/\/\s*@grant\s+(\S+)/ }
 
 export default {
     meta: {
@@ -13,7 +14,7 @@ export default {
             recommended: false,
             security: true
         },
-        defaultOptions: [{ target: 'all', allowedGrants: [], allowBroadConnect: false }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -45,14 +46,11 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] ?? {},
-              target = opts.target ?? 'all',
-              allowBroadConnect = opts.allowBroadConnect === true,
-              allowed = new Set(typeof opts.allowedGrants == 'string' ? [opts.allowedGrants]
-                      : opts.allowedGrants ?? []),
-              sourceCode = context.sourceCode ?? context.getSourceCode(),
-              managers = target == 'all' ? [...apis.managerSensitive.keys()]
-                       : Array.isArray(target) ? target : [target]
+        const { target, allowedGrants, allowBroadConnect } = { ...defaultOptions, ...context.options[0] },
+                allowed = new Set(typeof allowedGrants == 'string' ? [allowedGrants] : allowedGrants),
+                sourceCode = context.sourceCode ?? context.getSourceCode(),
+                managers = target == 'all' ? [...apis.managerSensitive.keys()]
+                         : Array.isArray(target) ? target : [target]
         const isSensitive = grant => apis.sensitive.has(grant)
             || managers.some(mgr => apis.managerSensitive.get(mgr)?.has(grant))
         const report = (line, messageId, data, col, len) => context.report({

package/src/rules/require-matching-localized-fields.js

@@ -1,5 +1,7 @@
 import metadata from '../utils/metadata.js'
 
+const defaultOptions = { ignoreLanguages: [] }
+
 export default {
     meta: {
         type: 'problem',
@@ -14,21 +16,20 @@ export default {
                 ignoreLanguages: {
                     anyOf: [
                         { type: 'string' },
-                        { type: 'array', items: { type: 'string' }, minItems: 1, uniqueItems: true }
+                        { type: 'array', items: { type: 'string' }, uniqueItems: true }
                     ],
                     description: 'Language code(s) to ignore'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{}],
+        defaultOptions: [defaultOptions],
         messages: { missingPair: 'Missing matching @{{missing}} for @{{present}}.' }
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              rawLangs = options.ignoreLanguages ?? [],
-              ignoreLangs = new Set(Array.isArray(rawLangs) ? rawLangs : [rawLangs])
+        const { ignoreLanguages } = { ...defaultOptions, ...context.options[0] },
+                ignoreLangs = new Set(Array.isArray(ignoreLanguages) ? ignoreLanguages : [ignoreLanguages])
         return {
             Program() {
                 const metaEntries = metadata.extract(context.sourceCode),

package/src/rules/require-required-fields.js

@@ -1,5 +1,7 @@
 import metadata from '../utils/metadata.js'
 
+const defaultOptions = { fields: ['name', 'version'], requireMatchOrInclude: true }
+
 export default {
     meta: {
         type: 'problem',
@@ -23,19 +25,17 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{}],
+        defaultOptions: [defaultOptions],
         messages: { missingField: 'Missing required metadata field: @{{field}}.' }
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              requiredFields = options.fields || ['name', 'version'],
-              requireMatchOrInclude = options.requireMatchOrInclude ?? true
+        const { fields, requireMatchOrInclude } = { ...defaultOptions, ...context.options[0] }
         return {
             Program(node) {
                 const metaEntries = metadata.extract(context.sourceCode),
                       keys = new Set(metaEntries.map(entry => entry.key))
-                for (const field of requiredFields)
+                for (const field of fields)
                     if (!keys.has(field))
                         context.report({ node, messageId: 'missingField', data: { field }})
                 if (requireMatchOrInclude && !['include', 'match'].some(field => keys.has(field)))

package/src/rules/require-sri-hashing.js

@@ -1,7 +1,11 @@
 import metadata from '../utils/metadata.js'
 
+const defaultOptions = { algorithm: 'sha256' }
 const re = {
-    hashEntry: /^(sha1|sha256|sha384|sha512|md5)[=-]([a-z0-9+/]+={0,2})$/i, hashFragment: /#([^#]+)$/, hashSep: /[,;]/ }
+    hashEntry: /^(sha1|sha256|sha384|sha512|md5)[=-]([a-z0-9+/]+={0,2})$/i,
+    hashFragment: /#([^#]+)$/,
+    hashSep: /[,;]/
+}
 
 export default {
     meta: {
@@ -23,12 +27,12 @@ export default {
                             minItems: 1, uniqueItems: true
                         }
                     ],
-                    description: 'SRI hash algorithm(s) to accept, as a single string or array (default: sha256)'
+                    description: 'SRI hash algorithm(s) to accept, as a single string or array'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ algorithm: 'sha256' }],
+        defaultOptions: [defaultOptions],
         messages: {
             missingHash: 'Missing SRI hash for @{{key}}.',
             invalidHash: 'Invalid SRI hash for @{{key}}.',
@@ -37,9 +41,9 @@ export default {
     },
 
     create(context) {
-        const rawAlgorithm = context.options[0]?.algorithm ?? 'sha256',
-              algorithms = (Array.isArray(rawAlgorithm) ? rawAlgorithm : [rawAlgorithm]).map(a => a.toLowerCase()),
-              expected = algorithms.join(' or ')
+        const { algorithm } = { ...defaultOptions, ...context.options[0] },
+                algorithms = (Array.isArray(algorithm) ? algorithm : [algorithm]).map(a => a.toLowerCase()),
+                expected = algorithms.join(' or ')
         return {
             'Program:exit'() {
                 for (const entry of metadata.extract(context.sourceCode)) {

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

@@ -1,13 +1,13 @@
 import metadata from '../utils/metadata.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = { versionType: 'semver', allowedGrants: [], allowFutureDate: false },
+      urlKeys = ['homepage', 'icon', 'icon64', 'require', 'source', 'website']
 const re = { // oxlint-disable security/detect-unsafe-regex
     semVer: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i,
     dateVer: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/
 } // oxlint-enable security/detect-unsafe-regex
 
-const urlKeys = ['homepage', 'icon', 'icon64', 'require', 'source', 'website']
-
 export default {
     meta: {
         type: 'problem',
@@ -22,7 +22,7 @@ export default {
                 versionType: {
                     type: 'string',
                     enum: ['semver', 'date'],
-                    description: 'Version format to enforce (default: semver)'
+                    description: 'Version format to enforce'
                 },
                 allowedGrants: {
                     type: 'array',
@@ -31,7 +31,7 @@ export default {
                 },
                 allowFutureDate: {
                     type: 'boolean',
-                    description: 'Allow @version dates later than the current date (default: false)'
+                    description: 'Allow @version dates later than the current date'
                 },
                 timezone: {
                     type: 'string',
@@ -40,7 +40,7 @@ export default {
             },
             additionalProperties: false
         }],
-        defaultOptions: [{}],
+        defaultOptions: [defaultOptions],
         messages: {
             invalidVersion: 'Invalid @version: must be a valid {{versionType}} (expected format: {{example}}).',
             futureVersion: 'Invalid @version: date cannot be in the future.',
@@ -50,11 +50,9 @@ export default {
     },
 
     create(context) {
-        const options = context.options[0] || {},
-              versionType = options.versionType || 'semver',
-              allowedGrants = new Set(options.allowedGrants || []),
-              allowFutureDate = options.allowFutureDate ?? false,
-              timezone = options.timezone,
+        const { versionType, allowedGrants, allowFutureDate, timezone }
+            = { ...defaultOptions, ...context.options[0] }
+        const allowedGrantsSet = new Set(allowedGrants),
               example = versionType == 'semver' ? '1.2.3' : 'YYYY.M.D or YYYY.MM.DD'
         const now = timezone
             ? Object.fromEntries(new Intl.DateTimeFormat('en', {
@@ -66,7 +64,7 @@ export default {
             Program() {
                 const metaEntries = metadata.extract(context.sourceCode)
                 for (const entry of metaEntries) {
-                    if (entry.key == 'grant' && allowedGrants.size && !allowedGrants.has(entry.value))
+                    if (entry.key == 'grant' && allowedGrantsSet.size && !allowedGrantsSet.has(entry.value))
                         context.report({ node: entry.comment, messageId: 'invalidGrant', data: { grant: entry.value }})
                     else if (entry.key == 'resource') {
                         const url = entry.value.trim().split(regex.whitespace.all)[1]

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

@@ -5,7 +5,8 @@ import license from '../utils/license.js'
 
 import regex from '../data/regex.js'
 
-const re = { spdxExpr: /(?<=\s)(?:OR|AND)(?=\s)/i }
+const defaultOptions = { allowedLicenses: [] },
+      re = { spdxExpr: /(?<=\s)(?:OR|AND)(?=\s)/i }
 
 export default {
     meta: {
@@ -15,7 +16,7 @@ export default {
             category: 'Possible Errors',
             recommended: true
         },
-        defaultOptions: [{ allowedLicenses: [] }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -36,9 +37,9 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] ?? {},
-              allowedLicenses = array.to(opts.allowedLicenses) ?? [],
-              sourceCode = context.sourceCode ?? context.getSourceCode()
+        const { allowedLicenses } = { ...defaultOptions, ...context.options[0] },
+                allowedLicensesArray = array.to(allowedLicenses),
+                sourceCode = context.sourceCode ?? context.getSourceCode()
         return {
             Program() {
                 const text = sourceCode.text,
@@ -61,11 +62,11 @@ export default {
                 for (const part of parts)
                     if (!license.spdx.isValid(part))
                         return context.report({ loc, messageId: 'invalidSPDX', data: { id: part }})
-                if (allowedLicenses.length) {
+                if (allowedLicensesArray.length) {
                     for (const part of parts)
-                        if (!allowedLicenses.includes(part))
+                        if (!allowedLicensesArray.includes(part))
                             return context.report({ loc, messageId: 'disallowedSPDX',
-                                data: { id: part, allowed: allowedLicenses.join(', ') }})
+                                data: { id: part, allowed: allowedLicensesArray.join(', ') }})
                 }
             }
         }

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

@@ -1,11 +1,16 @@
 import metadata from '../utils/metadata.js'
 import regex from '../data/regex.js'
 
+const defaultOptions = {
+    checkURLfields: true,
+    checkMatchPatterns: true,
+    allowedSchemes: ['http', 'https', 'file', 'ftp', 'http*'],
+    allowBroadPatterns: false
+}
 const re = {
     matchPattern: /^(\*|http\*?|https?|file|ftp):\/\/([^/]*)(\/.*)$/,
     regexForm: /^\/.+\/[a-z]*$/i
 }
-
 const urlKeys = new Set(['homepage', 'require', 'require-css', 'source', 'website']),
       matchKeys = new Set(['match', 'exclude-match']),
       regexOrMatchKeys = new Set(['include', 'exclude'])
@@ -18,12 +23,7 @@ export default {
             category: 'Possible Errors',
             recommended: true
         },
-        defaultOptions: [{
-            checkURLfields: true,
-            checkMatchPatterns: true,
-            allowedSchemes: ['http', 'https', 'file', 'ftp', 'http*'],
-            allowBroadPatterns: false
-        }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -57,11 +57,9 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] ?? {},
-              checkURLfields = opts.checkURLfields !== false,
-              checkMatchPatterns = opts.checkMatchPatterns !== false,
-              allowedSchemes = new Set(opts.allowedSchemes ?? ['http', 'https', 'file', 'ftp', 'http*']),
-              allowBroadPatterns = opts.allowBroadPatterns === true
+        const { checkURLfields, checkMatchPatterns, allowedSchemes, allowBroadPatterns }
+            = { ...defaultOptions, ...context.options[0] }
+        const allowedSchemeSet = new Set(allowedSchemes)
         if (!checkURLfields && !checkMatchPatterns) return {}
         function validateMatchPattern(value, field, node) {
             if (value == '<all_urls>') {
@@ -76,7 +74,7 @@ export default {
                 return
             }
             const [, scheme, host, path] = m
-            if (scheme != '*' && !allowedSchemes.has(scheme))
+            if (scheme != '*' && !allowedSchemeSet.has(scheme))
                 context.report({ node, messageId: 'invalidScheme', data: { field, value }})
             else if (scheme == 'file' && host != '')
                 context.report({ node, messageId: 'invalidFileHost', data: { field, value }})

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

@@ -1,12 +1,12 @@
 import metadata from '../utils/metadata.js'
 
+const defaultOptions = { versionType: 'semver', allowFutureDate: false, timezone: '' },
+      examples = { date: 'YYYY.M.D or YYYY.M.D.N', semver: '1.2.3' }
 const re = { // oxlint-disable security/detect-unsafe-regex
     date: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
     semver: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i
 } // oxlint-enable security/detect-unsafe-regex
 
-const examples = { date: 'YYYY.M.D or YYYY.M.D.N', semver: '1.2.3' }
-
 export default {
     meta: {
         type: 'problem',
@@ -15,7 +15,7 @@ export default {
             category: 'Possible Errors',
             recommended: true
         },
-        defaultOptions: [{ versionType: 'semver', allowFutureDate: false, timezone: '' }],
+        defaultOptions: [defaultOptions],
         schema: [{
             type: 'object',
             properties: {
@@ -44,11 +44,8 @@ export default {
     },
 
     create(context) {
-        const opts = context.options[0] ?? {},
-              versionType = opts.versionType ?? 'semver',
-              allowFutureDate = opts.allowFutureDate ?? false,
-              timezone = opts.timezone ?? '',
-              example = examples[versionType] // oxlint-disable-line security/detect-object-injection
+        const { versionType, allowFutureDate, timezone } = { ...defaultOptions, ...context.options[0] },
+                example = examples[versionType] // oxlint-disable-line security/detect-object-injection
         const now = timezone
             ? Object.fromEntries(new Intl.DateTimeFormat('en', {
                 timeZone: timezone, year: 'numeric', month: 'numeric', day: 'numeric'