@netlify/edge-bundler 14.2.0 → 14.2.1

package/dist/node/config.test.js

@@ -265,14 +265,14 @@ test('Loads function paths from the in-source `config` function', async () => {
         path: '/user-func1',
         headers: {
             'x-must-be-there': {
-                style: 'exists',
+                matcher: 'exists',
             },
             'x-must-match': {
                 pattern: '^(foo|bar)$',
-                style: 'regex',
+                matcher: 'regex',
             },
             'x-must-not-be-there': {
-                style: 'missing',
+                matcher: 'missing',
             },
         },
     });

package/dist/node/declaration.d.ts

@@ -2,9 +2,9 @@ import { FunctionConfig, HeadersConfig, HTTPMethod, Path } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
 export type HeaderMatch = {
     pattern: string;
-    style: 'regex';
+    matcher: 'regex';
 } | {
-    style: 'exists' | 'missing';
+    matcher: 'exists' | 'missing';
 };
 type HeaderMatchers = Record<string, HeaderMatch>;
 interface BaseDeclaration {

package/dist/node/declaration.js

@@ -130,10 +130,10 @@ export const getHeaderMatchers = (headers) => {
     }
     for (const header in headers) {
         if (typeof headers[header] === 'boolean') {
-            matchers[header] = { style: headers[header] ? 'exists' : 'missing' };
+            matchers[header] = { matcher: headers[header] ? 'exists' : 'missing' };
         }
         else if (typeof headers[header] === 'string') {
-            matchers[header] = { style: 'regex', pattern: normalizePattern(headers[header]) };
+            matchers[header] = { matcher: 'regex', pattern: normalizePattern(headers[header]) };
         }
         else {
             throw new BundleError(new Error(headerConfigError));

package/dist/node/manifest.test.js

@@ -215,11 +215,11 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
         },
     });
     const matcher = getRouteMatcher(manifest);
-    expect(matcher('/showcases/boho-style')).toBeDefined();
+    expect(matcher('/showcases/boho-matcher')).toBeDefined();
     expect(matcher('/checkout/address')).toBeDefined();
     expect(matcher('/checkout/terms-and-conditions')).toBeUndefined();
     expect(matcher('/checkout/scrooge-mc-duck-animation.css')).toBeUndefined();
-    expect(matcher('/showcases/boho-style/expensive-chair.jpg')).toBeUndefined();
+    expect(matcher('/showcases/boho-matcher/expensive-chair.jpg')).toBeUndefined();
 });
 test('URLPattern named groups are supported', () => {
     const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
@@ -570,25 +570,25 @@ describe('Header matching', () => {
                 path: '/f1/*',
                 headers: {
                     'x-absent': {
-                        style: 'missing',
+                        matcher: 'missing',
                     },
                     'x-also-present': {
-                        style: 'exists',
+                        matcher: 'exists',
                     },
                     'x-match-exact': {
                         pattern: '^exact$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-match-prefix': {
                         pattern: '^prefix(.*)$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-match-suffix': {
                         pattern: '^(.*)suffix$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-present': {
-                        style: 'exists',
+                        matcher: 'exists',
                     },
                 },
             },

package/dist/node/validation/manifest/index.test.js

@@ -143,35 +143,35 @@ describe('import map URL', () => {
     });
 });
 describe('route headers', () => {
-    test('should accept valid headers with exists style', () => {
+    test('should accept valid headers with exists matcher', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'exists',
+                matcher: 'exists',
             },
         };
         expect(() => validateManifest(manifest)).not.toThrowError();
     });
-    test('should accept valid headers with missing style', () => {
+    test('should accept valid headers with missing matcher', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'missing',
+                matcher: 'missing',
             },
         };
         expect(() => validateManifest(manifest)).not.toThrowError();
     });
-    test('should accept valid headers with regex style and pattern', () => {
+    test('should accept valid headers with regex matcher and pattern', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'regex',
+                matcher: 'regex',
                 pattern: '^Bearer .+$',
             },
         };
         expect(() => validateManifest(manifest)).not.toThrowError();
     });
-    test('should throw on missing style property', () => {
+    test('should throw on missing matcher property', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
@@ -180,20 +180,20 @@ describe('route headers', () => {
         };
         expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
-    test('should throw on invalid style value', () => {
+    test('should throw on invalid matcher value', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'invalid',
+                matcher: 'invalid',
             },
         };
         expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
-    test('should throw when style is regex but pattern is missing', () => {
+    test('should throw when matcher is regex but pattern is missing', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'regex',
+                matcher: 'regex',
             },
         };
         expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
@@ -202,7 +202,7 @@ describe('route headers', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'regex',
+                matcher: 'regex',
                 pattern: '/^Bearer .+/',
             },
         };
@@ -212,23 +212,23 @@ describe('route headers', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-custom-header': {
-                style: 'exists',
+                matcher: 'exists',
                 foo: 'bar',
             },
         };
         expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
-    test('should accept multiple headers with different styles', () => {
+    test('should accept multiple headers with different matchers', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].headers = {
             'x-exists-header': {
-                style: 'exists',
+                matcher: 'exists',
             },
             'x-missing-header': {
-                style: 'missing',
+                matcher: 'missing',
             },
             authorization: {
-                style: 'regex',
+                matcher: 'regex',
                 pattern: '^Bearer [a-zA-Z0-9]+$',
             },
         };

package/dist/node/validation/manifest/schema.d.ts

@@ -68,7 +68,7 @@ declare const edgeManifestSchema: {
                                         type: string;
                                         format: string;
                                     };
-                                    style: {
+                                    matcher: {
                                         type: string;
                                         enum: string[];
                                     };
@@ -76,7 +76,7 @@ declare const edgeManifestSchema: {
                                 additionalProperties: boolean;
                                 if: {
                                     properties: {
-                                        style: {
+                                        matcher: {
                                             const: string;
                                         };
                                     };
@@ -141,7 +141,7 @@ declare const edgeManifestSchema: {
                                         type: string;
                                         format: string;
                                     };
-                                    style: {
+                                    matcher: {
                                         type: string;
                                         enum: string[];
                                     };
@@ -149,7 +149,7 @@ declare const edgeManifestSchema: {
                                 additionalProperties: boolean;
                                 if: {
                                     properties: {
-                                        style: {
+                                        matcher: {
                                             const: string;
                                         };
                                     };

package/dist/node/validation/manifest/schema.js

@@ -20,13 +20,13 @@ const headersSchema = {
     patternProperties: {
         '.*': {
             type: 'object',
-            required: ['style'],
+            required: ['matcher'],
             properties: {
                 pattern: {
                     type: 'string',
                     format: 'regexPattern',
                 },
-                style: {
+                matcher: {
                     type: 'string',
                     enum: ['exists', 'missing', 'regex'],
                 },
@@ -34,7 +34,7 @@ const headersSchema = {
             additionalProperties: false,
             if: {
                 properties: {
-                    style: { const: 'regex' },
+                    matcher: { const: 'regex' },
                 },
             },
             then: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.2.0",
+  "version": "14.2.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,5 +81,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "9ba8975b7363b7003117aa0b224ad0d129c11ef4"
+  "gitHead": "18c4e2a28edc081235558f151b4c2d41b8e204e8"
 }