@api-client/core 0.6.31 → 0.7.2

package/src/cookies/CookieJar.ts

@@ -0,0 +1,26 @@
+import { IHttpCookie, HttpCookie } from '../models/HttpCookie.js';
+
+export abstract class CookieJar {
+  /**
+   * Requests the store to list all cookies that should be sent with the HTTP request.
+   * 
+   * @param url The request URL to match the cookies for.
+   */
+  abstract listCookies(url: string): Promise<HttpCookie[]>;
+
+  /**
+   * Writes cookies to the store.
+   * 
+   * @param url The request URL the cookies were set for.
+   * @param cookies The list of cookies to store.
+   */
+  abstract setCookies(url: string, cookies: IHttpCookie[] | HttpCookie[]): Promise<void>;
+
+  /**
+   * Deletes cookies by the URL and optionally by name.
+   * 
+   * @param url The URL to delete the cookies for.
+   * @param name The name of the cookie. When not set it deletes all cookies for the URL.
+   */
+  abstract deleteCookies(url: string, name?: string): Promise<void>;
+}

package/src/cookies/CookieParser.ts

@@ -0,0 +1,327 @@
+/* eslint-disable no-control-regex */
+import { Punycode } from "./Punycode.js";
+import { HttpCookie } from '../models/HttpCookie.js';
+
+export type SameSiteValue = 'Lax' | 'Strict' | 'None';
+
+const cookieParts: (keyof HttpCookie)[] = [
+  'path',
+  'domain',
+  'max-age',
+  'expires',
+  'secure',
+  'httponly',
+  'samesite',
+  'hostonly',
+];
+
+const v6reStr = `
+\\[?(?:
+(?:[a-fA-F\\d]{1,4}:){7}(?:[a-fA-F\\d]{1,4}|:)|
+(?:[a-fA-F\\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|:[a-fA-F\\d]{1,4}|:)|
+(?:[a-fA-F\\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,2}|:)|
+(?:[a-fA-F\\d]{1,4}:){4}(?:(?::[a-fA-F\\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,3}|:)|
+(?:[a-fA-F\\d]{1,4}:){3}(?:(?::[a-fA-F\\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,4}|:)|
+(?:[a-fA-F\\d]{1,4}:){2}(?:(?::[a-fA-F\\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,5}|:)|
+(?:[a-fA-F\\d]{1,4}:){1}(?:(?::[a-fA-F\\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,6}|:)|
+(?::(?:(?::[a-fA-F\\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,7}|:))
+)(?:%[0-9a-zA-Z]{1,})?\\]?
+`
+  .replace(/\s*\/\/.*$/gm, "")
+  .replace(/\n/g, "")
+  .trim();
+
+const ipV6re = new RegExp(`^${v6reStr}$`);
+
+/**
+ * A class that parses the `set-cookie` header string to a list of cookies.
+ */
+export class CookieParser {
+  /**
+   * Creates a cookie canonical domain from the full request URL.
+   * 
+   * @param url The HTTP request URL.
+   * @returns The canonical domain for the URL.
+   */
+  static canonicalDomainUrl(url: string): string {
+    const parser = new URL(url);
+    return this.canonicalDomain(parser.host);
+  }
+
+  /**
+   * Creates a cookie canonical domain from the host name.
+   * 
+   * @param host The same as `new URL('...').host`.
+   * @returns The canonical domain for the URL.
+   */
+  static canonicalDomain(host: string): string {
+    let str = host;
+    str = str.trim();
+    if (ipV6re.test(str)) {
+      str = str.replace("[", "").replace("]", "");
+    }
+    if (/[^\u0001-\u007f]/.test(str)) {
+      str = Punycode.toASCII(str);
+    }
+    // if (str[0] !== '.') {
+    //   str = `.${str}`;
+    // }
+    return str.toLowerCase();
+  }
+
+  /**
+   * Parses the `set-cookie` header value and creates a list of cookies.
+   * The cookie configuration must match the `url`. This means that if the cookie has a `host` property
+   * this must match the request URL (browsers do not allow setting cookies from one domain for another).
+   * 
+   * When `host` or `path` part is missing from the cookie, the URL values are used.
+   * 
+   * @param requestUrl The HTTP request URL. Cookies must match this URL or will be ignored.
+   * @param setCookie The value of the `set-cookie` string.
+   */
+  static parse(requestUrl: string, setCookie?: string): HttpCookie[] {
+    const result: HttpCookie[] = [];
+    if (!setCookie || typeof setCookie !== 'string') {
+      return result;
+    }
+    const blocks = setCookie.split(';').map(i => i.trim());
+    blocks.forEach((part, index) => {
+      // Consider the following set-cookie string:
+      // c1=v1; Path=/; Expires=Wed, 09 Feb 2022 01:30:04 GMT; HttpOnly,c2=v2; Path=/,c3=v3; Path=/; Secure; SameSite=Strict
+      // It is a valid set-cookie header event though it mixes different formatting making it harder to parse cookies.
+      // This loop looks for invalid parts and creates a canonical cookie parts array.
+      const periodIndex = part.indexOf(',');
+      if (periodIndex === -1) {
+        return;
+      }
+      if (part.toLowerCase().startsWith('expires=')) {
+        return;
+      }
+      const tmp = part.split(',');
+      // remove current
+      blocks.splice(index, 1);
+      // add the new two
+      blocks.splice(index, 0, ...tmp);
+    });
+    blocks.forEach((cookie) => {
+      const parts = cookie.split(/=/, 2);
+      if (parts.length === 0) {
+        return;
+      }
+      const name = decodeURIComponent(parts[0].trim());
+      if (!name) {
+        return;
+      }
+      const lowerName = name.toLowerCase() as keyof HttpCookie;
+      let value: string | boolean | undefined;
+      if (parts.length > 1) {
+        try {
+          value = decodeURIComponent(parts[1].trim());
+        } catch (e) {
+          value = parts[1];
+        }
+      } else {
+        value = true;
+      }
+      // if this is an attribute of previous cookie, set it for last
+      // added cookie.
+      if (cookieParts.includes(lowerName)) {
+        if (result.length - 1 >= 0) {
+          const attr = lowerName as keyof HttpCookie;
+          const previousCookie = result[result.length - 1];
+          if (attr === 'samesite') {
+            const typed = value as SameSiteValue;
+            switch (typed.toLowerCase()) {
+              case 'lax': previousCookie[attr] = 'lax'; break;
+              case 'strict': previousCookie[attr] = 'strict'; break;
+              case 'none': previousCookie[attr] = 'no_restriction'; break;
+            }
+          } else {
+            previousCookie[attr] = value as never;
+          }
+        }
+      } else {
+        try {
+          result.push(new HttpCookie({
+            name, 
+            value: value as string,
+            sameSite: 'unspecified',
+          }));
+        } catch (e) {
+          // ..
+        }
+      }
+    });
+
+    // At this point we have all cookies set by the server. Now we need to filter out cookies 
+    // set for a different domains.
+
+    // first lets set cookie domain and path.
+    const url = new URL(requestUrl);
+    const domain = this.canonicalDomain(url.host);
+    const path = this.getPath(url);
+
+    result.forEach((cookie) => {
+      if (!cookie.path) {
+        cookie.path = path;
+      }
+      if (!cookie.domain) {
+        // point 6. of https://tools.ietf.org/html/rfc6265#section-5.3
+        cookie.domain = domain;
+        cookie.hostOnly = true;
+      } else if (cookie.domain[0] !== '.') {
+        // https://stackoverflow.com/a/1063760/1127848
+        cookie.domain = `.${cookie.domain}`;
+      }
+    });
+    return this.filterCookies(result, requestUrl);
+  }
+
+  /**
+   * Filters a list of cookies to match the given `requestUrl`.
+   * This means that both the `domain` and the `path` part of the cookie must match the URL.
+   * 
+   * @param cookies The list of cookies to filter.
+   * @param requestUrl The request URL to filter against.
+   * @returns The filtered list of cookies that can be used with the URL.
+   */
+  static filterCookies(cookies: HttpCookie[], requestUrl: string): HttpCookie[] {
+    const url = new URL(requestUrl);
+    const domain = this.canonicalDomain(url.host);
+    return cookies.filter((cookie) => {
+      if (!cookie.path || !cookie.domain) {
+        return false;
+      }
+      return this.matchesDomain(cookie.domain, domain) && this.matchesPath(cookie.path, url);
+    });
+  }
+
+  /**
+   * Gets the path for a domain as defined in
+   * https://tools.ietf.org/html/rfc6265#section-5.1.4
+   */
+  static getPath(url: URL): string {
+    let value = url.pathname;
+    // /a/b/c -> /a/b
+    // /a/b/c/ -> /a/b/c
+    // /a -> /
+    // /a/ -> /a
+    let index = value.indexOf('/', 1);
+    if (index === -1) {
+      return '/';
+    }
+    index = value.lastIndexOf('/');
+    if (index !== 0) {
+      value = value.substring(0, index);
+    }
+    return value;
+  }
+
+  /**
+   * This follows the algorithm defined in https://tools.ietf.org/html/rfc6265#section-5.1.3
+   * 
+   * @param string A string to test whether it matches the domain.
+   * @param domain The domain to compare to
+   * @return True if domains matches.
+   */
+  static matchesDomain(string: string, domain: string): boolean {
+    if (!string || !domain) {
+      return false;
+    }
+
+    let canonicalString = this.canonicalDomain(string);
+    const canonicalDomain = this.canonicalDomain(domain);
+
+    if (canonicalString[0] === '.') {
+      canonicalString = canonicalString.substring(1);
+    }
+
+    // section-5.1.3 p.1
+    if (canonicalString === canonicalDomain) {
+      return true;
+    }
+    
+    // section-5.1.3 p.2.1
+    // The domain string is a suffix of the string.
+    if (canonicalDomain.endsWith(canonicalString)) {
+      // section-5.1.3 p.2.2
+      // The last character of the string that is not included 
+      // in the domain string is a %x2E (".") character.
+      const index = canonicalDomain.indexOf(canonicalString);
+      const char = canonicalDomain.substring(index - 1, index);
+      if (char === '.') {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Checks if paths mach as defined in
+   * https://tools.ietf.org/html/rfc6265#section-5.1.4
+   *
+   * Note: This function will return false if the `this.url` was not set.
+   *
+   * @param cookiePath Path from the cookie.
+   * @param url
+   * @return True when paths matches.
+   */
+  static matchesPath(cookiePath: string, url: URL): boolean {
+    if (!cookiePath) {
+      return true;
+    }
+    const requestPath = this.getPath(url);
+    return this._matchesPath(cookiePath, requestPath);
+    
+    // const index = requestPath.indexOf(cookiePath);
+    // if (index === 0 && cookiePath[cookiePath.length - 1] === '/') {
+    //   return true;
+    // }
+    // if (index === 0 && cookiePath.indexOf('/', 1) === -1) {
+    //   return true;
+    // }
+
+    // if (index === 0) {
+    //   // eslint-disable-next-line no-plusplus
+    //   for (let i = 0, len = requestPath.length; i < len; i++) {
+    //     if (cookiePath.indexOf(requestPath[i]) === -1 && requestPath[i] === '/') {
+    //       return true;
+    //     }
+    //   }
+    // }
+  }
+
+  protected static _matchesPath(cookiePath: string, requestPath: string): boolean {
+    // p1: The cookie-path and the request-path are identical.
+    if (requestPath === cookiePath) {
+      return true;
+    }
+
+    // p2,p3: The cookie-path is a prefix of the request-path ...
+    if (requestPath.startsWith(cookiePath)) {
+      // p2: and the last character of the cookie-path is U+002F ("/").
+      if (cookiePath.endsWith('/')) {
+        return true;
+      }
+      // p3: and the first character of the request-path that is not included in the cookie-path 
+      // is a U+002F ("/") character.
+      if (requestPath.replace(cookiePath, '')[0] === '/') {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  static matchesCookie(c1: HttpCookie, c2: HttpCookie): boolean {
+    if (c1.name !== c2.name) {
+      return false;
+    }
+    if (!c1.domain || !c2.domain) {
+      return false;
+    }
+    if (!c1.path || !c2.path) {
+      return false;
+    }
+    return this.matchesDomain(c1.domain, c2.domain) && this._matchesPath(c1.path, c2.path);
+  }
+}

package/src/cookies/InMemoryCookieJar.ts

@@ -0,0 +1,70 @@
+import { CookieJar } from "./CookieJar.js";
+import { CookieParser } from "./CookieParser.js";
+import { IHttpCookie, HttpCookie } from '../models/HttpCookie.js';
+
+const cache: HttpCookie[] = [];
+
+export function clearStore(): void {
+  cache.splice(0);
+}
+
+export class InMemoryCookieJar extends CookieJar {
+  /**
+   * Clears the memory store from all values.
+   */
+  clear(): void {
+    cache.splice(0);
+  }
+
+  async deleteCookies(requestUrl: string, name?: string): Promise<void> {
+    const url = new URL(requestUrl);
+    const domain = CookieParser.canonicalDomain(url.host);
+    for (let i = cache.length - 1; i >= 0; i--) {
+      const cookie = cache[i];
+      if (!cookie.path || !cookie.domain) {
+        continue
+      }
+      if (name && name !== cookie.name) {
+        continue;
+      }
+      if (CookieParser.matchesDomain(cookie.domain, domain) && CookieParser.matchesPath(cookie.path, url)) {
+        cache.splice(i, 1);
+      }
+    }
+  }
+
+  async listCookies(url: string): Promise<HttpCookie[]> {
+    return CookieParser.filterCookies(cache, url);
+  }
+
+  async setCookies(url: string, cookies: HttpCookie[] | IHttpCookie[]): Promise<void> {
+    const uri = new URL(url);
+    const domain = CookieParser.canonicalDomain(uri.host);
+    const path = CookieParser.getPath(uri);
+    cookies.forEach((cookie) => {
+      let typed: HttpCookie;
+      if (typeof (cookie as HttpCookie).toJSON !== 'function') {
+        typed = new HttpCookie(cookie);
+      } else {
+        typed = cookie as HttpCookie;
+      }
+      if (!typed.path) {
+        typed.path = path;
+      }
+      if (!typed.domain) {
+        // point 6. of https://tools.ietf.org/html/rfc6265#section-5.3
+        typed.domain = domain;
+        typed.hostOnly = true;
+      } else if (typed.domain[0] !== '.') {
+        // https://stackoverflow.com/a/1063760/1127848
+        typed.domain = `.${typed.domain}`;
+      }
+      const index = cache.findIndex(cached => CookieParser.matchesCookie(typed, cached));
+      if (index >= 0) {
+        cache[index] = typed;
+      } else {
+        cache.push(typed);
+      }
+    });
+  }
+}

package/src/cookies/Punycode.ts

@@ -0,0 +1,133 @@
+const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
+const regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars
+const maxInt = 2147483647;
+const base = 36;
+const tMin = 1;
+const tMax = 26;
+const damp = 700;
+const skew = 38;
+const baseMinusTMin = base - tMin;
+const overflowError = 'Overflow: input needs wider integers to process';
+
+/**
+ * This is a short copy of https://github.com/mathiasbynens/punycode.js/blob/master/punycode.js
+ * but written for ESM and browsers.
+ * All credits to the original author: Mathias Bynens
+ */
+export class Punycode {
+  static toASCII(input: string): string {
+    let result = '';
+    const parts = input.split('@');
+    if (parts.length > 1) {
+      result = parts[0] + '@';
+      input = parts[1];
+    }
+    input = input.replace(regexSeparators, '\x2E');
+    const labels = input.split('.');
+    const encoded = labels.map((part) => {
+      return regexNonASCII.test(part) ? 'xn--' + this.encode(part) : part;
+    }).join('.');
+    return result + encoded;
+  }
+
+  protected static encode(value: string): string {
+    const output = [];
+    const input = this.ucs2decode(value);
+    const inputLength = input.length;
+    let n = 128;
+    let delta = 0;
+    let bias = 72;
+    for (const currentValue of input) {
+      if (currentValue < 0x80) {
+        output.push(String.fromCharCode(currentValue));
+      }
+    }
+    const basicLength = output.length;
+    let handledCPCount = basicLength;
+    if (basicLength) {
+      output.push('-');
+    }
+    while (handledCPCount < inputLength) {
+      let m = maxInt;
+      for (const currentValue of input) {
+        if (currentValue >= n && currentValue < m) {
+          m = currentValue;
+        }
+      }
+
+      const handledCPCountPlusOne = handledCPCount + 1;
+      if (m - n > Math.floor((maxInt - delta) / handledCPCountPlusOne)) {
+        throw new RangeError(overflowError);
+      }
+
+      delta += (m - n) * handledCPCountPlusOne;
+      n = m;
+
+      for (const currentValue of input) {
+        if (currentValue < n && ++delta > maxInt) {
+          throw new RangeError(overflowError);
+        }
+        if (currentValue == n) {
+          // Represent delta as a generalized variable-length integer.
+          let q = delta;
+          for (let k = base; /* no condition */; k += base) {
+            const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+            if (q < t) {
+              break;
+            }
+            const qMinusT = q - t;
+            const baseMinusT = base - t;
+            output.push(
+              String.fromCharCode(this.digitToBasic(t + qMinusT % baseMinusT, 0))
+            );
+            q = Math.floor(qMinusT / baseMinusT);
+          }
+  
+          output.push(String.fromCharCode(this.digitToBasic(q, 0)));
+          bias = this.adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+          delta = 0;
+          ++handledCPCount;
+        }
+      }
+      ++delta;
+      ++n;
+    }
+    return output.join('');
+  }
+
+  protected static digitToBasic(digit: number, flag: number): number {
+    return digit + 22 + 75 * (digit < 26 ? 1 : 0) - ((flag !== 0 ? 1 : 0) << 5);
+  }
+
+  protected static adapt(delta: number, numPoints: number, firstTime: boolean): number {
+    let k = 0;
+    delta = firstTime ? Math.floor(delta / damp) : delta >> 1;
+    delta += Math.floor(delta / numPoints);
+    for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+      delta = Math.floor(delta / baseMinusTMin);
+    }
+    return Math.floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+  }
+
+  protected static ucs2decode(input: string): number[] {
+    const result: number[] = [];
+    let i = 0;
+    const len = input.length;
+
+    while (i < len) {
+      const value = input.charCodeAt(i++);
+      if (value >= 0xD800 && value <= 0xDBFF && i < len) {
+        const extra = input.charCodeAt(i++);
+        if ((extra & 0xFC00) == 0xDC00) {
+          result.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+        } else {
+          result.push(value);
+          i--;
+        }
+      } else {
+        result.push(value);
+      }
+    }
+    return result;
+  }
+}

package/src/data/RequestDataExtractor.ts

@@ -3,8 +3,7 @@ import { IHttpRequest, HttpRequest } from '../models/HttpRequest.js';
 import { ISentRequest, SentRequest } from '../models/SentRequest.js';
 import { IHttpResponse, HttpResponse } from '../models/HttpResponse.js';
 import { IErrorResponse, ErrorResponse } from '../models/ErrorResponse.js';
-import { IDataSource } from '../models/actions/Condition.js';
-import { ActionTypeEnum } from '../models/actions/Enums.js';
+import { ActionRequestDataEnum, ActionResponseDataEnum, ActionSourceEnum } from '../models/http-actions/HttpActions.js';
 import { Headers } from '../lib/headers/Headers.js';
 import { JsonReader } from './JsonReader.js';
 import { XmlReader } from './XmlReader.js';
@@ -19,10 +18,12 @@ export class RequestDataExtractor {
    * The request that has been sent to the server.
    */
   request: HttpRequest | SentRequest;
+
   /**
    * The response object
    */
   response?: HttpResponse | ErrorResponse;
+
   constructor(request: IHttpRequest | ISentRequest, response?: IHttpResponse | IErrorResponse) {
     this.request = new HttpRequest(request);
     if (response) {
@@ -37,28 +38,26 @@ export class RequestDataExtractor {
   /**
    * Reads the data from the selected path.
    * 
-   * @param config The configuration of the data source
+   * @param source The source of the data to read. Note, variables are not supported here.
+   * @param data The kind of data to read the value from
+   * @param path The path to the data.
    * @return Data to be processed
    */
-  async extract(config: IDataSource): Promise<string | number | undefined> {
-    const { type, source, path, value } = config;
-    if (source === 'value') {
-      return value;
-    }
+  async extract(source: ActionSourceEnum, data?: ActionRequestDataEnum | ActionResponseDataEnum, path?: string): Promise<string | number | undefined> {
     const args = path ? path.split('.') : [];
-    switch (source) {
+    switch (data) {
       case 'url':
         return DataUtils.getDataUrl(this.getUrl(), args);
       case 'headers':
-        return DataUtils.getDataHeaders(this.getHeaders(type), args);
+        return DataUtils.getDataHeaders(this.getHeaders(source), args);
       case 'status':
         return this.response && this.response.status;
       case 'method':
         return this.request.method;
       case 'body':
-        return this.processBody(path, type);
+        return this.processBody(path, source);
       default:
-        throw new Error(`Unknown source ${source} for ${type} data`);
+        throw new Error(`Unknown data ${data} for ${source} data`);
     }
   }
 
@@ -74,14 +73,14 @@ export class RequestDataExtractor {
    * @param source The source name 
    * @returns The headers from the request / response
    */
-  getHeaders(source?: ActionTypeEnum): string {
+  getHeaders(source?: ActionSourceEnum): string {
     if (source === 'request') {
       return this.request.headers || '';
     }
     return this.response && this.response.headers || '';
   }
 
-  async processBody(path?: string, source?: ActionTypeEnum): Promise<string | undefined> {
+  async processBody(path?: string, source?: ActionSourceEnum): Promise<string | undefined> {
     const value = await this.getBody(source);
     if (!value) {
       return undefined;
@@ -105,7 +104,7 @@ export class RequestDataExtractor {
    * @param source The source name 
    * @returns The headers from the request / response
    */
-  async getBody(source?: ActionTypeEnum): Promise<string | undefined> {
+  async getBody(source?: ActionSourceEnum): Promise<string | undefined> {
     if (source === 'request') {
       return this.request.readPayloadAsString();
     }

package/src/events/CustomEvent.ts

@@ -15,6 +15,10 @@ if (typeof CustomEvent === 'function') {
       super(type, eventInitDict);
       if (eventInitDict && eventInitDict.detail) {
         this[detailSymbol] = eventInitDict.detail;
+      } else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this[detailSymbol] = null;
       }
     }
 

package/src/mocking/ProjectMock.ts

@@ -6,12 +6,13 @@ import { History } from './lib/History.js';
 import { Url } from './lib/Url.js';
 import { Certificates } from './lib/Certificates.js';
 import { HostRules } from './lib/HostRules.js';
-import { Arc } from './lib/Arc.js';
+import { App } from './lib/App.js';
 
 export { IRequestLogInit } from './lib/Request.js';
 export { IResponseInit } from './lib/Response.js';
 export { IUserInit } from './lib/User.js';
 export { IHttpHistoryInit, IHttpHistoryListInit } from './lib/History.js';
+export { IAppRequestInit } from './lib/App.js';
 
 export class ProjectMock extends DataMock {
   projectRequest: Request;
@@ -21,7 +22,7 @@ export class ProjectMock extends DataMock {
   url: Url;
   certificates: Certificates;
   hostRules: HostRules;
-  arc: Arc;
+  app: App;
   
   /**
    * @param init The library init options.
@@ -35,6 +36,6 @@ export class ProjectMock extends DataMock {
     this.url = new Url(init);
     this.certificates = new Certificates(init);
     this.hostRules = new HostRules(init);
-    this.arc = new Arc(init);
+    this.app = new App(init);
   }
 }