webext-patterns 1.2.0 → 1.4.0

package/index.d.ts

@@ -1,5 +1,9 @@
 export declare const patternValidationRegex: RegExp;
 export declare const allStarsRegex: RegExp;
 export declare const allUrlsRegex: RegExp;
+export declare function assertValidPattern(matchPattern: string): void;
+export declare function isValidPattern(matchPattern: string): boolean;
+export declare function doesUrlMatchPatterns(url: string, ...matchPattern: string[]): boolean;
 export declare function patternToRegex(...matchPatterns: readonly string[]): RegExp;
 export declare function globToRegex(...globs: readonly string[]): RegExp;
+export declare function excludeDuplicatePatterns(matchPatterns: readonly string[]): string[];

package/index.js

@@ -1,28 +1,53 @@
 import escapeStringRegexp from 'escape-string-regexp';
 // Copied from https://github.com/mozilla/gecko-dev/blob/073cc24f53d0cf31403121d768812146e597cc9d/toolkit/components/extensions/schemas/manifest.json#L487-L491
 export const patternValidationRegex = /^(https?|wss?|file|ftp|\*):\/\/(\*|\*\.[^*/]+|[^*/]+)\/.*$|^file:\/\/\/.*$|^resource:\/\/(\*|\*\.[^*/]+|[^*/]+)\/.*$|^about:/;
-const isFirefox = typeof navigator === 'object' && navigator.userAgent.includes('Firefox/');
+const isFirefox = globalThis.navigator?.userAgent.includes('Firefox/');
 export const allStarsRegex = isFirefox
     ? /^(https?|wss?):[/][/][^/]+([/].*)?$/
     : /^https?:[/][/][^/]+([/].*)?$/;
 export const allUrlsRegex = /^(https?|file|ftp):[/]+/;
-function getRawPatternRegex(matchPattern) {
-    if (!patternValidationRegex.test(matchPattern)) {
+export function assertValidPattern(matchPattern) {
+    if (!isValidPattern(matchPattern)) {
         throw new Error(matchPattern + ' is an invalid pattern, it must match ' + String(patternValidationRegex));
     }
-    let [, protocol, host, pathname] = matchPattern.split(/(^[^:]+:[/][/])([^/]+)?/);
+}
+export function isValidPattern(matchPattern) {
+    return matchPattern === '<all_urls>' || patternValidationRegex.test(matchPattern);
+}
+export function doesUrlMatchPatterns(url, ...matchPattern) {
+    if (matchPattern.includes('<all_urls>') && allUrlsRegex.test(url)) {
+        return true;
+    }
+    if (matchPattern.includes('*://*/*') && allStarsRegex.test(url)) {
+        return true;
+    }
+    for (const pattern of matchPattern) {
+        if (patternToRegex(pattern).test(url)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getRawPatternRegex(matchPattern) {
+    assertValidPattern(matchPattern);
+    // Host undefined for file:///
+    let [, protocol, host = '', pathname] = matchPattern.split(/(^[^:]+:[/][/])([^/]+)?/);
     protocol = protocol
         .replace('*', isFirefox ? '(https?|wss?)' : 'https?') // Protocol wildcard
-        .replace(/[/]/g, '[/]'); // Escape slashes
-    host = (host !== null && host !== void 0 ? host : '') // Undefined for file:///
-        .replace(/^[*][.]/, '([^/]+.)*') // Initial wildcard
-        .replace(/^[*]$/, '[^/]+') // Only wildcard
-        .replace(/[.]/g, '[.]') // Escape dots
-        .replace(/[*]$/g, '[^.]+'); // Last wildcard
+        .replaceAll(/[/]/g, '[/]'); // Escape slashes
+    if (host === '*') {
+        host = '[^/]+';
+    }
+    else if (host) {
+        host = host
+            .replace(/^[*][.]/, '([^/]+.)*') // Initial wildcard
+            .replaceAll(/[.]/g, '[.]') // Escape dots
+            .replace(/[*]$/, '[^.]+'); // Last wildcard
+    }
     pathname = pathname
-        .replace(/[/]/g, '[/]') // Escape slashes
-        .replace(/[.]/g, '[.]') // Escape dots
-        .replace(/[*]/g, '.*'); // Any wildcard
+        .replaceAll(/[/]/g, '[/]') // Escape slashes
+        .replaceAll(/[.]/g, '[.]') // Escape dots
+        .replaceAll(/[*]/g, '.*'); // Any wildcard
     return '^' + protocol + host + '(' + pathname + ')?$';
 }
 export function patternToRegex(...matchPatterns) {
@@ -74,3 +99,12 @@ export function globToRegex(...globs) {
     }
     return new RegExp(globs.map(x => getRawGlobRegex(x)).join('|'));
 }
+export function excludeDuplicatePatterns(matchPatterns) {
+    if (matchPatterns.includes('<all_urls>')) {
+        return ['<all_urls>'];
+    }
+    if (matchPatterns.includes('*://*/*')) {
+        return ['*://*/*'];
+    }
+    return matchPatterns.filter(possibleSubset => !matchPatterns.some(possibleSuperset => possibleSubset !== possibleSuperset && patternToRegex(possibleSuperset).test(possibleSubset)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "webext-patterns",
-	"version": "1.2.0",
+	"version": "1.4.0",
 	"description": "Tool to convert the patterns and globs of your WebExtension manifest to regex",
 	"keywords": [
 		"browser",
@@ -17,11 +17,12 @@
 		"webext"
 	],
 	"repository": "fregante/webext-patterns",
+	"funding": "https://github.com/sponsors/fregante",
 	"license": "MIT",
 	"author": "Federico Brigante <me@fregante.com> (https://fregante.com)",
 	"type": "module",
-	"main": "index.js",
-	"module": "index.js",
+	"exports": "./index.js",
+	"types": "./index.d.ts",
 	"files": [
 		"index.js",
 		"index.d.ts"
@@ -47,13 +48,16 @@
 		"escape-string-regexp": "^5.0.0"
 	},
 	"devDependencies": {
-		"@sindresorhus/tsconfig": "^3.0.1",
-		"@types/chrome": "0.0.190",
-		"ava": "^4.3.0",
-		"sinon": "^14.0.0",
-		"type-fest": "^2.13.1",
-		"typescript": "^4.7.4",
-		"xo": "^0.50.0"
+		"@sindresorhus/tsconfig": "^5.0.0",
+		"@types/chrome": "0.0.256",
+		"ava": "^6.0.1",
+		"sinon": "^17.0.1",
+		"type-fest": "^4.9.0",
+		"typescript": "^5.3.3",
+		"xo": "^0.56.0"
+	},
+	"engines": {
+		"node": ">=18"
 	},
 	"webExt": {
 		"sourceDir": "demo-extension",

package/readme.md

@@ -19,22 +19,38 @@ npm install webext-patterns
 
 ```js
 // This module is only offered as a ES Module
-import {patternToRegex} from 'webext-patterns';
+import {
+	patternToRegex,
+	globToRegex,
+	excludeDuplicatePatterns
+	doesUrlMatchPatterns,
+	assertValidPattern,
+	isValidPattern,
+} from 'webext-patterns';
 ```
 
 ## Usage
 
-> **Note**
-> Firefox and Chrome handle globs very slighly differently. `webext-patterns` defaults to Chrome’s logic, but if it detects a Firefox userAgent it will produce a Firefox-compatible regex.
-
 ```js
 patternToRegex('http://*/*');
 // Returns /^http:[/][/][^/]+[/].+$/
 
 globToRegex('*.example.com');
 // Returns /\.example\.com$/
+
+excludeDuplicatePatterns(['https://*.google.com/*', 'https://google.com/*']);
+// Returns ['https://*.google.com/*']
+
+assertValidPattern('https://google.*/*');
+// Throws an error because the pattern is invalid
+
+isValidPattern('https://*.google.com/*');
+// Returns true
 ```
 
+> **Note**
+> Firefox and Chrome handle patterns very slighly differently. `webext-patterns` defaults to Chrome’s logic, but if it detects a Firefox userAgent it will produce a Firefox-compatible regex.
+
 ## API
 
 #### patternToRegex(pattern1, pattern2, etc)
@@ -84,6 +100,46 @@ googleRegex.test('https://google.it/search'); // -> true
 googleRegex.test('https://google.de/search'); // -> false
 ```
 
+#### excludeDuplicatePatterns([pattern1, pattern2, etc])
+
+Accepts an array of patterns and returns a filtered array without the patterns that are already covered by others. For example `"https://*/*"` already covers all "https" URLs, so having `"https://google.com/*"` in the array won't make any difference and therefore it's dropped.
+
+```js
+excludeDuplicatePatterns([
+	"https://*/*",
+	"https://google.com/*",
+	"https://*.example.com/*",
+]);
+// Returns ["https://*/*"]
+```
+
+#### doesUrlMatchPatterns(url, ...patterns)
+
+Accepts a URL and any number of patterns and returns `true` if the URL matches any of the patterns. This is a convenience method that wraps `patternToRegex` for single use. If you plan on testing multiple URLs to the same pattern, it's better to convert the patterns to a regex once and reuse that.
+
+```js
+doesUrlMatchPatterns('https://google.com/', ['https://*.google.com/*', '*://example.com/*']);
+// Returns true
+```
+
+#### assertValidPattern(pattern)
+
+Accepts a pattern and throws an error if it's invalid.
+
+```js
+assertValidPattern('https://google.*/*');
+// Throws an error because the pattern is invalid
+```
+
+#### isValidPattern(pattern)
+
+Accepts a pattern and returns `true` if it's valid.
+
+```js
+isValidPattern('https://google.*/*');
+// Returns false
+```
+
 ## Related
 
 ### Permissions