fix: make ?/# pre-processing conditional on template operators; don't throw on literal ? at construction

Author: felixweinberger

packages/core/src/shared/uriTemplate.ts

@@ -43,19 +43,6 @@ export class UriTemplate {
         UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, 'Template');
         this.template = template;
         this.parts = this.parse(template);
-
-        // Templates with a literal '?' in a string segment are incompatible
-        // with match()'s split-at-'?' query parsing — the path regex would
-        // include the escaped '?' but the URI is split before matching.
-        // Supporting this requires a fragile two-code-path implementation
-        // that has proven bug-prone, so reject at construction time.
-        const literalQueryPart = this.parts.find(part => typeof part === 'string' && part.includes('?'));
-        if (literalQueryPart !== undefined) {
-            throw new Error(
-                `UriTemplate: literal '?' in template string is not supported. ` +
-                    `Use {?param} to introduce query parameters instead. Template: "${template}"`
-            );
-        }
     }
 
     toString(): string {
@@ -297,14 +284,27 @@ export class UriTemplate {
             }
         }
 
-        // Strip any URI fragment before splitting path/query.
-        const hashIndex = uri.indexOf('#');
-        const uriNoFrag = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+        // Only strip the URI fragment when the template has no {#var} operator;
+        // otherwise the fragment is part of what the path regex must capture.
+        const hasHashOperator = this.parts.some(p => typeof p !== 'string' && p.operator === '#');
+        let working = uri;
+        if (!hasHashOperator) {
+            const hashIndex = working.indexOf('#');
+            if (hashIndex !== -1) working = working.slice(0, hashIndex);
+        }
 
-        // Split URI into path and query parts at the first '?'
-        const queryIndex = uriNoFrag.indexOf('?');
-        const pathPart = queryIndex === -1 ? uriNoFrag : uriNoFrag.slice(0, queryIndex);
-        const queryPart = queryIndex === -1 ? '' : uriNoFrag.slice(queryIndex + 1);
+        // Only split path/query when the template actually has {?..}/{&..}
+        // operators. Otherwise match the path regex against the full URI so
+        // {+var} can capture across '?' as it did before query-param support.
+        let pathPart = working;
+        let queryPart = '';
+        if (queryParts.length > 0) {
+            const queryIndex = working.indexOf('?');
+            if (queryIndex !== -1) {
+                pathPart = working.slice(0, queryIndex);
+                queryPart = working.slice(queryIndex + 1);
+            }
+        }
 
         pattern += '$';
         UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, 'Generated regex pattern');

packages/core/test/shared/uriTemplate.test.ts

@@ -256,12 +256,20 @@ describe('UriTemplate', () => {
             expect(template.match('/search?q=%ZZ')).toEqual({ q: '%ZZ' });
         });
 
-        it('should reject templates with literal ? in a string segment', () => {
-            expect(() => new UriTemplate('/path?fixed=1')).toThrow(/literal '\?'/);
-            expect(() => new UriTemplate('/path?static=1{?dynamic}')).toThrow(/literal '\?'/);
-            expect(() => new UriTemplate('/path?static=1{&dynamic}')).toThrow(/literal '\?'/);
-            expect(() => new UriTemplate('/api?v=2{&key,page}')).toThrow(/literal '\?'/);
-            expect(() => new UriTemplate('/api/{version}?format=json{&key}')).toThrow(/literal '\?'/);
+        it('should not throw on literal ? in a string segment (expand-only usage)', () => {
+            expect(() => new UriTemplate('/path?fixed=1')).not.toThrow();
+            expect(() => new UriTemplate('http://e.com/?literal').expand({})).not.toThrow();
+            expect(new UriTemplate('http://e.com/?literal').expand({})).toBe('http://e.com/?literal');
+        });
+
+        it('should let {+var} capture across ? when template has no query operators', () => {
+            const template = new UriTemplate('http://e.com{+rest}');
+            expect(template.match('http://e.com/search?q=hello')).toEqual({ rest: '/search?q=hello' });
+        });
+
+        it('should let {#var} capture the fragment', () => {
+            const template = new UriTemplate('/page{#section}');
+            expect(template.match('/page#intro')).toEqual({ section: '#intro' });
         });
 
         it('should accept templates using {?param} for query parameters', () => {