@openelement/url-pattern-list 0.6.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Justin Fagnani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+# @openelement/url-pattern-list
+
+Efficiently match URL paths against a collection of URL patterns using a
+fixed pathname-literal index with conservative fallback.
+
+> **Fork note:** this is the OpenElement-maintained fork of
+> [justinfagnani/url-pattern-list](https://github.com/justinfagnani/url-pattern-list)
+> v0.5.0. See [PROVENANCE.md](./PROVENANCE.md) for sources and license, and
+> [DIVERGENCE.md](./DIVERGENCE.md) for what differs and why.
+
+## Overview
+
+`url-pattern-list` is a JavaScript library that provides an efficient way to
+match URLs against multiple
+[URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern)
+instances. Instead of testing every pattern linearly, `URLPatternList`
+indexes patterns whose pathname is a canonical literal in a fixed prefix
+tree, keeps all other patterns in a conservative list, and merges both by
+registration order at match time — so only patterns that can possibly match
+are exec'd.
+
+`URLPatternList` has exactly the same matching semantics as scanning a
+linear list of patterns, and is differentially tested against such a linear
+oracle for both native and polyfill URLPattern constructors. The first
+pattern (in the order patterns were added to the list) whose complete
+`exec()` matches a URL is returned as the match.
+
+Patterns are added to the list along with an additional value that is returned
+with the match. This makes it easy to associate a URLPattern with metadata or an
+object like a server route handler.
+
+## Installation
+
+```sh
+npm i @openelement/url-pattern-list
+```
+
+## Quick Start
+
+```typescript
+import {URLPatternList} from '@openelement/url-pattern-list';
+
+// Create a new pattern list
+const routes = new URLPatternList<string>();
+
+// Add patterns with associated values
+routes.addPattern(new URLPattern({pathname: '/api/users/:id'}), 'user-detail');
+routes.addPattern(new URLPattern({pathname: '/api/users'}), 'user-list');
+routes.addPattern(new URLPattern({pathname: '/api/posts/:id'}), 'post-detail');
+
+// Match against a URL
+const match = routes.match('/api/users/123');
+if (match) {
+  console.log('Route:', match.value); // 'user-detail'
+  console.log('User ID:', match.result.pathname.groups.id); // '123'
+}
+```
+
+## Performance
+
+Lookup cost is driven by the number of candidate patterns exec'd, not the
+number of patterns registered: static-heavy workloads exec a handful of
+candidates at any scale, while workloads dominated by non-literal patterns
+(regex, groups, wildcards) degrade gracefully to linear scan. Benchmarks
+cover construction, hit, miss and memory against a linear oracle and
+upstream v0.5.0; see [BENCHMARKS.md](./BENCHMARKS.md) for numbers and
+methodology.
+
+To run the benchmark on your machine:
+
+```sh
+npm i --prefix .tmp-upstream url-pattern-list@0.5.0 # optional comparison
+npm run benchmark
+```
+
+## API Reference
+
+### URLPatternList&lt;T&gt;
+
+The main class for managing and matching URL patterns.
+
+```ts
+import {URLPatternList} from '@openelement/url-pattern-list';
+```
+
+#### Methods
+
+##### `addPattern(pattern: ListPattern, value: T): void`
+
+Add a URL pattern to the collection with an associated value. `ListPattern`
+is any object with a `pathname` getter and the `exec()` method of the
+URLPattern interface — native `URLPattern` and `urlpattern-polyfill`
+instances both work.
+
+```typescript
+const list = new URLPatternList<RouteHandler>();
+list.addPattern(new URLPattern({pathname: '/users/:id'}), handleUserDetail);
+```
+
+##### `match(url: string | URL, baseUrl?: string): URLPatternListMatch<T> | null`
+
+Match a URL against all patterns, returning the first match found. Relative
+string input requires `baseUrl`; invalid input throws a `TypeError`, even
+for an empty list.
+
+```typescript
+const match = list.match('/users/123', 'https://example.com');
+if (match) {
+  // match.result contains the URLPatternResult
+  // match.value contains your associated value
+}
+```
+
+##### `candidateCount(url: string | URL, baseUrl?: string): number`
+
+Diagnostic upper bound on how many patterns `match()` would exec for the
+given input. Not part of the matching semantics.
+
+### Types
+
+#### URLPatternListMatch&lt;T&gt;
+
+```typescript
+interface URLPatternListMatch<T> {
+  result: URLPatternResult; // Standard URLPattern match result
+  value: T; // Your associated value
+}
+```
+
+## Browser Support
+
+This library works with any
+[URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern)
+implementation you supply — native:
+
+- Chrome 95+
+- Firefox 142+ (Preview support)
+- Safari 26.0+ (Preview support)
+
+— or the [URLPattern
+polyfill](https://github.com/kenchris/urlpattern-polyfill) (patterns built
+from either constructor can be mixed in one list).
+
+## Visualizer
+
+The upstream visualizer was removed in 0.6.0 because it rendered the
+internals of the removed per-component prefix tree. See
+[DIVERGENCE.md](./DIVERGENCE.md).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) file for details.
+
+## Related
+
+- [URLPattern on
+  MDN](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern)
+- [URLPattern Specification](https://urlpattern.spec.whatwg.org/)
+- [URLPattern Polyfill](https://github.com/kenchris/urlpattern-polyfill)

package/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * url-pattern-list - efficiently match URLs against a collection of URL
+ * patterns.
+ *
+ * This implementation is derived from the semantics OpenElement established
+ * for its maintained fork: only canonical pathname literals are indexed, every
+ * other pattern is matched conservatively, and candidates are merged by
+ * registration order before a full `exec()` decides the match. See
+ * PROVENANCE.md and DIVERGENCE.md.
+ */
+/**
+ * The minimal pattern interface stored by a URLPatternList.
+ *
+ * Any object with a `pathname` getter and the `exec()` method of the
+ * URLPattern interface works: native `URLPattern` instances and
+ * polyfill (`urlpattern-polyfill`) instances alike. Pattern parsing,
+ * compilation and capture semantics belong entirely to the pattern's
+ * constructor; this library only stores, indexes and matches patterns in
+ * registration order.
+ */
+export interface ListPattern {
+    readonly pathname: string;
+    exec(input: string, baseURL?: string): URLPatternResult | null;
+}
+/**
+ * The return type of `URLPatternList.match()`.
+ *
+ * Includes the result of `pattern.exec()` and the matching pattern's associated
+ * metadata value.
+ */
+export interface URLPatternListMatch<T> {
+    result: URLPatternResult;
+    value: T;
+}
+/**
+ * A collection of URL patterns and associated values, with methods for adding
+ * patterns and matching URLs against those patterns.
+ *
+ * Patterns with a canonical pathname literal are stored in a fixed prefix tree
+ * keyed by that literal; all other patterns are stored in a conservative list.
+ * Matching execs the candidates of both collections in registration order and
+ * returns the first complete match. This maintains first-match-wins
+ * semantics - the result is the same as scanning a linear list of patterns -
+ * while only execing the patterns that can possibly match.
+ *
+ * Pruning is based solely on canonical pathname literal equality, which is a
+ * necessary condition for `exec()` to match. Pruning never involves other URL
+ * components, so empty URL components never disappear from matching and the
+ * final `exec()` sees every pattern that could match.
+ */
+export declare class URLPatternList<T> {
+    #private;
+    /**
+     * Add a URL pattern to the collection.
+     */
+    addPattern(pattern: ListPattern, value: T): void;
+    /**
+     * Match a URL against the URLPatterns, returning the first match found and
+     * its associated value.
+     *
+     * The input is normalized once with the `URL` constructor and both pruning
+     * and `exec()` consume the same normalized URL. Invalid input throws a
+     * `TypeError`, including for an empty list; relative string input requires a
+     * `baseUrl`.
+     *
+     * @param url - The URL to match
+     * @param baseUrl - Optional base URL for relative path resolution
+     */
+    match(url: string | URL, baseUrl?: string): URLPatternListMatch<T> | null;
+    /**
+     * Diagnostic upper bound on the number of patterns that `match()` would
+     * exec for the given input. Not part of the matching semantics; no matcher
+     * internals are exposed.
+     */
+    candidateCount(url: string | URL, baseUrl?: string): number;
+}
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;CAChE;AAaD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,CAAC,CAAC;CACV;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc,CAAC,CAAC;;IAK3B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAqChD;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI;IAwCzE;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;CAI5D"}

package/index.js

@@ -0,0 +1,160 @@
+/**
+ * url-pattern-list - efficiently match URLs against a collection of URL
+ * patterns.
+ *
+ * This implementation is derived from the semantics OpenElement established
+ * for its maintained fork: only canonical pathname literals are indexed, every
+ * other pattern is matched conservatively, and candidates are merged by
+ * registration order before a full `exec()` decides the match. See
+ * PROVENANCE.md and DIVERGENCE.md.
+ */
+/**
+ * A node in the fixed pathname prefix tree. Each node holds the patterns whose
+ * canonical pathname literal ends exactly at this node.
+ */
+class FixedPrefixTreeNode {
+    children = new Map();
+    patterns = [];
+}
+/**
+ * Returns the index key for a pattern pathname, or `undefined` if the pathname
+ * is not a canonical literal.
+ *
+ * This is deliberately a small literal alphabet, not a URLPattern grammar
+ * parser. These characters have no pattern operators or escapes. Every other
+ * spelling remains conservative, including groups, regex, empty paths and
+ * Unicode.
+ *
+ * ASCII case folding over-selects candidates for case-sensitive patterns and
+ * admits ignoreCase patterns without relying on a non-standard URLPattern
+ * options getter; `exec()` still determines the real case semantics.
+ */
+const literalPathnameKey = (pathname) => {
+    if (!pathname.startsWith('/')) {
+        return undefined;
+    }
+    for (const char of pathname) {
+        if (!'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/_-.%~'.includes(char)) {
+            return undefined;
+        }
+    }
+    return pathname.toLowerCase();
+};
+/**
+ * A collection of URL patterns and associated values, with methods for adding
+ * patterns and matching URLs against those patterns.
+ *
+ * Patterns with a canonical pathname literal are stored in a fixed prefix tree
+ * keyed by that literal; all other patterns are stored in a conservative list.
+ * Matching execs the candidates of both collections in registration order and
+ * returns the first complete match. This maintains first-match-wins
+ * semantics - the result is the same as scanning a linear list of patterns -
+ * while only execing the patterns that can possibly match.
+ *
+ * Pruning is based solely on canonical pathname literal equality, which is a
+ * necessary condition for `exec()` to match. Pruning never involves other URL
+ * components, so empty URL components never disappear from matching and the
+ * final `exec()` sees every pattern that could match.
+ */
+export class URLPatternList {
+    #root = new FixedPrefixTreeNode();
+    #conservative = [];
+    #sequenceCounter = 0;
+    /**
+     * Add a URL pattern to the collection.
+     */
+    addPattern(pattern, value) {
+        const item = {
+            sequence: this.#sequenceCounter++,
+            pattern,
+            value,
+        };
+        const key = literalPathnameKey(pattern.pathname);
+        if (key === undefined) {
+            this.#conservative.push(item);
+            return;
+        }
+        let node = this.#root;
+        for (const char of key) {
+            let child = node.children.get(char);
+            if (child === undefined) {
+                child = new FixedPrefixTreeNode();
+                node.children.set(char, child);
+            }
+            node = child;
+        }
+        node.patterns.push(item);
+    }
+    /**
+     * The patterns whose canonical pathname literal equals the URL's pathname.
+     */
+    #fixedCandidates(url) {
+        let node = this.#root;
+        for (const char of url.pathname.toLowerCase()) {
+            node = node.children.get(char);
+            if (node === undefined) {
+                return [];
+            }
+        }
+        return node.patterns;
+    }
+    /**
+     * Match a URL against the URLPatterns, returning the first match found and
+     * its associated value.
+     *
+     * The input is normalized once with the `URL` constructor and both pruning
+     * and `exec()` consume the same normalized URL. Invalid input throws a
+     * `TypeError`, including for an empty list; relative string input requires a
+     * `baseUrl`.
+     *
+     * @param url - The URL to match
+     * @param baseUrl - Optional base URL for relative path resolution
+     */
+    match(url, baseUrl) {
+        const normalized = new URL(String(url), baseUrl);
+        const fullURL = normalized.href;
+        const fixed = this.#fixedCandidates(normalized);
+        // Merge the fixed-tree candidates and the conservative candidates by
+        // original sequence, so the first complete exec match in registration
+        // order wins. Both arrays are already sorted by sequence.
+        let fixedIndex = 0;
+        let conservativeIndex = 0;
+        while (fixedIndex < fixed.length ||
+            conservativeIndex < this.#conservative.length) {
+            let item;
+            if (fixedIndex >= fixed.length) {
+                item = this.#conservative[conservativeIndex++];
+            }
+            else if (conservativeIndex >= this.#conservative.length) {
+                item = fixed[fixedIndex++];
+            }
+            else if (fixed[fixedIndex].sequence <
+                this.#conservative[conservativeIndex].sequence) {
+                item = fixed[fixedIndex++];
+            }
+            else {
+                item = this.#conservative[conservativeIndex++];
+            }
+            // Pass baseUrl through to exec like upstream did, so the result's
+            // `inputs` reflect the caller's arguments. The normalized URL is
+            // absolute, so the base never changes whether exec matches.
+            const result = baseUrl === undefined
+                ? item.pattern.exec(fullURL)
+                : item.pattern.exec(fullURL, baseUrl);
+            if (result !== null) {
+                return { result, value: item.value };
+            }
+        }
+        return null;
+    }
+    /**
+     * Diagnostic upper bound on the number of patterns that `match()` would
+     * exec for the given input. Not part of the matching semantics; no matcher
+     * internals are exposed.
+     */
+    candidateCount(url, baseUrl) {
+        const normalized = new URL(String(url), baseUrl);
+        return this.#fixedCandidates(normalized).length + this.#conservative.length;
+    }
+}
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@openelement/url-pattern-list",
+  "version": "0.6.0",
+  "description": "Efficiently match URLs against a collection of URL patterns",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "build": "wireit",
+    "test": "wireit",
+    "benchmark": "wireit",
+    "format": "npm run format:fix",
+    "format:check": "prettier \"**/*.{cjs,html,js,json,md,ts}\" --check",
+    "format:fix": "prettier \"**/*.{cjs,html,js,json,md,ts}\" --write"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/url-pattern-list.git"
+  },
+  "keywords": [
+    "url",
+    "urlpattern",
+    "url-pattern"
+  ],
+  "author": "Justin Fagnani <justin@fagnani.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/open-element/url-pattern-list/issues"
+  },
+  "homepage": "https://github.com/open-element/url-pattern-list#readme",
+  "devDependencies": {
+    "@types/node": "^24.2.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-curly": "^0.3.2",
+    "typescript": "^5.9.2",
+    "urlpattern-polyfill": "^10.1.0",
+    "wireit": "^0.14.12"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "index.js.map",
+    "index.d.ts.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "wireit": {
+    "build": {
+      "command": "tsc --build",
+      "files": [
+        "tsconfig.json",
+        "src/**/*.ts"
+      ],
+      "outputs": [
+        "index.{js,d.ts,js.map,d.ts.map}"
+      ],
+      "clean": "if-file-deleted"
+    },
+    "test": {
+      "command": "node --enable-source-maps --test --test-reporter=spec \"test/**/*_test.js\"",
+      "dependencies": [
+        "build"
+      ],
+      "files": [],
+      "output": []
+    },
+    "benchmark": {
+      "command": "node --expose-gc --enable-source-maps benchmark/benchmark.js",
+      "dependencies": [
+        "build"
+      ],
+      "files": [],
+      "output": []
+    }
+  }
+}