@netlify/headers-parser 7.2.0 → 8.0.0

package/lib/all.d.ts

@@ -1,9 +1,11 @@
+import type { Header, MinimalHeader } from './types.js';
+export type { Header, MinimalHeader };
 export declare const parseAllHeaders: ({ headersFiles, netlifyConfigPath, configHeaders, minimal, }: {
-    headersFiles?: never[] | undefined;
-    netlifyConfigPath: any;
-    configHeaders?: never[] | undefined;
-    minimal?: boolean | undefined;
+    headersFiles: undefined | string[];
+    netlifyConfigPath?: undefined | string;
+    configHeaders: undefined | MinimalHeader[];
+    minimal: boolean;
 }) => Promise<{
-    headers: import("./types.js").Header[];
+    headers: (MinimalHeader | Header)[];
     errors: Error[];
 }>;

package/lib/all.js

@@ -5,7 +5,7 @@ import { normalizeHeaders } from './normalize.js';
 import { splitResults, concatResults } from './results.js';
 // Parse all headers from `netlify.toml` and `_headers` file, then normalize
 // and validate those.
-export const parseAllHeaders = async function ({ headersFiles = [], netlifyConfigPath, configHeaders = [], minimal = false, }) {
+export const parseAllHeaders = async function ({ headersFiles = [], netlifyConfigPath, configHeaders = [], minimal, }) {
     const [{ headers: fileHeaders, errors: fileParseErrors }, { headers: parsedConfigHeaders, errors: configParseErrors },] = await Promise.all([getFileHeaders(headersFiles), getConfigHeaders(netlifyConfigPath)]);
     const { headers: normalizedFileHeaders, errors: fileNormalizeErrors } = normalizeHeaders(fileHeaders, minimal);
     const { headers: normalizedConfigParseHeaders, errors: configParseNormalizeErrors } = normalizeHeaders(parsedConfigHeaders, minimal);

package/lib/for_regexp.d.ts

@@ -1 +1 @@
-export function getForRegExp(forPath: any): RegExp;
+export declare const getForRegExp: (forPath: string) => RegExp;

package/lib/index.d.ts

@@ -1 +1 @@
-export { parseAllHeaders } from './all.js';
+export { parseAllHeaders, type Header, type MinimalHeader } from './all.js';

package/lib/line_parser.d.ts

@@ -1,4 +1,6 @@
-export declare const parseFileHeaders: (headersFile: string) => Promise<{
-    headers: any;
-    errors: any[];
-}>;
+import type { MinimalHeader } from './types.js';
+export interface ParseHeadersResult {
+    headers: MinimalHeader[];
+    errors: Error[];
+}
+export declare const parseFileHeaders: (headersFile: string) => Promise<ParseHeadersResult>;

package/lib/line_parser.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import fs from 'fs/promises';
 import { pathExists } from 'path-exists';
 import { splitResults } from './results.js';
 // Parse `_headers` file to an array of objects following the same syntax as
@@ -18,7 +18,12 @@ const parseHeaders = async function (headersFile) {
     if (typeof text !== 'string') {
         return [text];
     }
-    return text.split('\n').map(normalizeLine).filter(hasHeader).map(parseLine).filter(Boolean);
+    return text
+        .split('\n')
+        .map(normalizeLine)
+        .filter(hasHeader)
+        .map(parseLine)
+        .filter((line) => line != null);
 };
 const readHeadersFile = async function (headersFile) {
     try {
@@ -41,7 +46,7 @@ const parseLine = function ({ line, index }) {
     catch (error) {
         return new Error(`Could not parse header line ${index + 1}:
   ${line}
-${error.message}`);
+${error instanceof Error ? error.message : error?.toString()}`);
     }
 };
 // Parse a single header line
@@ -53,7 +58,7 @@ const parseHeaderLine = function (line) {
         return;
     }
     const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
-    const name = rawName.trim();
+    const name = rawName?.trim() ?? '';
     if (name === '') {
         throw new Error(`Missing header name`);
     }
@@ -67,16 +72,18 @@ const isPathLine = function (line) {
     return line.startsWith('/');
 };
 const HEADER_SEPARATOR = ':';
-const reduceLine = function ({ headers, errors }, { path, name, value }) {
-    if (path !== undefined) {
+const reduceLine = function ({ headers, errors }, parsedHeader) {
+    if ('path' in parsedHeader) {
+        const { path } = parsedHeader;
         return { headers: [...headers, { for: path, values: {} }], errors };
     }
-    if (headers.length === 0) {
+    const { name, value } = parsedHeader;
+    const previousHeaders = headers.slice(0, -1);
+    const currentHeader = headers[headers.length - 1];
+    if (headers.length === 0 || currentHeader == null) {
         const error = new Error(`Path should come before header "${name}"`);
         return { headers, errors: [...errors, error] };
     }
-    const previousHeaders = headers.slice(0, -1);
-    const currentHeader = headers[headers.length - 1];
     const { values } = currentHeader;
     const newValue = values[name] === undefined ? value : `${values[name]}, ${value}`;
     const newHeaders = [...previousHeaders, { ...currentHeader, values: { ...values, [name]: newValue } }];

package/lib/merge.d.ts

@@ -1,8 +1,8 @@
-import type { Header } from './types.js';
+import type { Header, MinimalHeader } from './types.js';
 export declare const mergeHeaders: ({ fileHeaders, configHeaders, }: {
-    fileHeaders: (Error | Header)[];
-    configHeaders: (Error | Header)[];
+    fileHeaders: MinimalHeader[] | Header[];
+    configHeaders: MinimalHeader[] | Header[];
 }) => {
-    headers: Header[];
+    headers: (MinimalHeader | Header)[];
     errors: Error[];
 };

package/lib/merge.js

@@ -28,13 +28,12 @@ export const mergeHeaders = function ({ fileHeaders, configHeaders, }) {
 const removeDuplicates = function (headers) {
     const uniqueHeaders = new Set();
     const result = [];
-    for (let i = headers.length - 1; i >= 0; i--) {
-        const h = headers[i];
-        const key = generateHeaderKey(h);
+    for (const header of [...headers].reverse()) {
+        const key = generateHeaderKey(header);
         if (uniqueHeaders.has(key))
             continue;
         uniqueHeaders.add(key);
-        result.push(h);
+        result.push(header);
     }
     return result.reverse();
 };

package/lib/netlify_config_parser.d.ts

@@ -1,4 +1,5 @@
+import type { MinimalHeader } from './types.js';
 export declare const parseConfigHeaders: (netlifyConfigPath: string) => Promise<{
-    headers: any[];
+    headers: MinimalHeader[];
     errors: Error[];
 }>;

package/lib/netlify_config_parser.js

@@ -22,6 +22,7 @@ const parseConfig = async function (configPath) {
         if (!Array.isArray(headers)) {
             throw new TypeError(`"headers" must be an array`);
         }
+        // TODO(serhalp) Validate shape instead of assuming and asserting type
         return headers;
     }
     catch (error) {

package/lib/normalize.d.ts

@@ -1,8 +1,12 @@
-import type { Header } from './types.js';
-export declare const normalizeHeaders: (headers: any, minimal: boolean) => {
-    headers: Header[];
+import type { Header, MinimalHeader } from './types.js';
+export interface MinimalNormalizedHeaders {
+    headers: MinimalHeader[];
     errors: Error[];
-} | {
-    headers: TypeError[];
+}
+export interface NormalizedHeaders {
+    headers: Header[];
     errors: Error[];
-};
+}
+export declare function normalizeHeaders(headers: MinimalHeader[], minimal: true): MinimalNormalizedHeaders;
+export declare function normalizeHeaders(headers: MinimalHeader[], minimal: false): NormalizedHeaders;
+export declare function normalizeHeaders(headers: MinimalHeader[], minimal: boolean): MinimalNormalizedHeaders | NormalizedHeaders;

package/lib/normalize.js

@@ -2,34 +2,34 @@ import isPlainObj from 'is-plain-obj';
 import mapObj from 'map-obj';
 import { getForRegExp } from './for_regexp.js';
 import { splitResults } from './results.js';
-// Validate and normalize an array of `headers` objects.
-// This step is performed after `headers` have been parsed from either
-// `netlify.toml` or `_headers`.
-export const normalizeHeaders = function (headers, minimal) {
+export function normalizeHeaders(headers, minimal) {
     if (!Array.isArray(headers)) {
         const error = new TypeError(`Headers must be an array not: ${headers}`);
+        // This looks odd but it is correct: it takes an array of `T | Error` and returns `{values: T[]: errors: Error[]}`,
+        // thus when given a literal array of type `Error[]` it can't infer `T`, so we explicitly pass in `never` as `T`.
         return splitResults([error]);
     }
+    // TODO(serhalp) Workaround for poor TS type narrowing. Remove once on typescript@5.8.
     const results = headers
-        .map((header, index) => parseHeader(header, index, minimal))
-        .filter(Boolean);
+        .map((header, index) => (minimal ? parseHeader(header, index, true) : parseHeader(header, index, false)))
+        .filter((header) => header != null);
     return splitResults(results);
-};
-const parseHeader = function (header, index, minimal) {
+}
+function parseHeader(header, index, minimal) {
     if (!isPlainObj(header)) {
         return new TypeError(`Header must be an object not: ${header}`);
     }
     try {
-        return parseHeaderObject(header, minimal);
+        // TODO(serhalp) Workaround for poor TS type narrowing. Remove once on typescript@5.8.
+        return minimal ? parseHeaderObject(header, true) : parseHeaderObject(header, false);
     }
     catch (error) {
         return new Error(`Could not parse header number ${index + 1}:
   ${JSON.stringify(header)}
-${error.message}`);
+${error instanceof Error ? error.message : error?.toString()}`);
     }
-};
-// Parse a single `headers` object
-const parseHeaderObject = function ({ for: rawPath, values: rawValues }, minimal) {
+}
+function parseHeaderObject({ for: rawPath, values: rawValues }, minimal) {
     const forPath = normalizePath(rawPath);
     if (rawValues === undefined) {
         return;
@@ -42,11 +42,14 @@ const parseHeaderObject = function ({ for: rawPath, values: rawValues }, minimal
         for: forPath,
         values,
     };
-    if (!minimal) {
-        header.forRegExp = getForRegExp(forPath);
+    if (minimal) {
+        return header;
     }
-    return header;
-};
+    return {
+        ...header,
+        forRegExp: getForRegExp(forPath),
+    };
+}
 // Normalize and validate the `for` field
 const normalizePath = function (rawPath) {
     if (rawPath === undefined) {

package/lib/results.d.ts

@@ -1,12 +1,12 @@
-import type { Header } from './types.js';
-export declare function splitResults<Type>(results: (Error | Type)[]): {
-    headers: Type[];
+import type { MinimalHeader } from './types.js';
+export declare function splitResults<T>(results: (Error | T)[]): {
+    headers: T[];
     errors: Error[];
 };
 export declare const concatResults: (resultsArrays: {
-    headers: Header[];
+    headers: MinimalHeader[];
     errors: Error[];
 }[]) => {
-    headers: Header[];
+    headers: MinimalHeader[];
     errors: Error[];
 };

package/lib/types.d.ts

@@ -1,7 +1,9 @@
-export type Header = {
+export interface MinimalHeader {
     for: string;
-    forRegExp?: RegExp;
     values: {
         [key: string]: string;
     };
-};
+}
+export interface Header extends MinimalHeader {
+    forRegExp: RegExp;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/headers-parser",
-  "version": "7.2.0",
+  "version": "8.0.0",
   "description": "Parses Netlify headers into a JavaScript object representation",
   "type": "module",
   "exports": "./lib/index.js",
@@ -47,5 +47,5 @@
     "url": "https://github.com/netlify/build/issues"
   },
   "homepage": "https://github.com/netlify/build#readme",
-  "gitHead": "131a644bfde5205f730f3369b778d8914c7c0382"
+  "gitHead": "65206cf82369d2e0412c707c763590690cc1819a"
 }