@api-client/core 0.6.18 → 0.6.19

package/src/amf/Parsing.ts

@@ -0,0 +1,49 @@
+export interface AmfServiceProcessingOptions {
+  /**
+   * When true it treats the source as a zip data. Files are unzipped to a temporary location before processing.
+   */
+  zip?: boolean;
+  /**
+   * When true it validates the API when parsing.
+   * 
+   * Validation is made in the `parse` phase and results (as string) are stored in the `validationResult` property of the service.
+   */
+  validate?: boolean;
+  /**
+   * The main file to use, if known
+   */
+  mainFile?: string;
+}
+
+export interface ApiSearchCandidate {
+  /**
+   * Absolute path to the file
+   */
+  absolute: string;
+  /**
+   * Relative path to the file
+   */
+  relative: string;
+}
+
+export interface ApiSearchTypeResult {
+  /**
+   * API type
+   */
+  type: string;
+  /**
+   * File media type
+   */
+  contentType: string;
+}
+
+export interface ApiParseResult {
+  /**
+   * The parsed API
+   */
+  model: string;
+  /**
+   * Api type info
+   */
+  type: ApiSearchTypeResult;
+}

package/src/events/EventTypes.ts

@@ -7,8 +7,10 @@ import { ReportingEventTypes } from './reporting/ReportingEventTypes.js';
 import { TelemetryEventTypes } from './telemetry/TelemetryEventTypes.js';
 import { EnvironmentEventTypes } from './environment/EnvironmentEventTypes.js';
 import { TransportEventTypes } from './transport/TransportEventTypes.js';
+import { AmfEventTypes } from './amf/AmfEventTypes.js';
 
 export const EventTypes = Object.freeze({
+  Amf: AmfEventTypes,
   Authorization: AuthorizationEventTypes,
   Cookie: CookieEventTypes,
   Encryption: EncryptionEventTypes,

package/src/events/Events.ts

@@ -7,8 +7,10 @@ import { ReportingEvents } from './reporting/ReportingEvents.js';
 import { TelemetryEvents } from './telemetry/TelemetryEvents.js';
 import { TransportEvent } from './transport/TransportEvents.js';
 import { EnvironmentEvents } from './environment/EnvironmentEvents.js';
+import { AmfEvents } from './amf/AmfEvents.js';
 
 export const Events = Object.freeze({
+  Amf: AmfEvents,
   Authorization: AuthorizationEvents,
   Cookie: CookieEvents,
   Encryption: EncryptionEvents,

package/src/events/amf/AmfEventTypes.ts

@@ -0,0 +1,6 @@
+export const AmfEventTypes = Object.freeze({
+  processApiLink: 'amfprocessapilink',
+  processBuffer: 'amfprocessbuffer',
+  processApiFile: 'amfprocessapifile',
+  selectApiMainFile: 'amfselectapimainfile',
+});

package/src/events/amf/AmfEvents.ts

@@ -0,0 +1,63 @@
+import { ApiParseResult, AmfServiceProcessingOptions } from "../../amf/Parsing.js";
+import { ContextEvent } from "../BaseEvents.js";
+import { AmfEventTypes } from './AmfEventTypes.js'
+
+export class AmfEvents {
+  /**
+   * Downloads the file and processes it as a zipped API project.
+   *
+   * @param url API remote location.
+   * @param mainFile API main file. If not set the program will try to find the best match.
+   * @param md5 When set it will test data integrity with the MD5 hash
+   * @param packaging Default to `zip`.
+   * @returns Promise resolved to the AMF json-ld model.
+   */
+  static async processApiLink(url: string, mainFile?: string, md5?: string, packaging?: string, target: EventTarget = window): Promise<ApiParseResult> {
+    const e = new ContextEvent(AmfEventTypes.processApiLink, {
+      url, mainFile, md5, packaging,
+    });
+    target.dispatchEvent(e);
+    return (e.detail.result as unknown) as Promise<ApiParseResult>;
+  }
+
+  /**
+   * Parses API data to AMF model.
+   * @param buffer Buffer created from API file.
+   * @param opts Processing options
+   * @returns Promise resolved to the AMF json-ld model
+   */
+  static async processBuffer(buffer: Buffer, opts?: AmfServiceProcessingOptions, target: EventTarget = window): Promise<ApiParseResult> {
+    const e = new ContextEvent(AmfEventTypes.processBuffer, {
+      buffer, opts,
+    });
+    target.dispatchEvent(e);
+    return (e.detail.result as unknown) as Promise<ApiParseResult>;
+  }
+
+  /**
+   * Processes file data.
+   * If the blob is a type of `application/zip` it processes the file as a
+   * zip file. Otherwise it processes it as a file.
+   *
+   * @param file File to process.
+   * @returns Promise resolved to the AMF json-ld model
+   */
+  static async processApiFile(file: File | Blob, target: EventTarget = window): Promise<ApiParseResult> {
+    const e = new ContextEvent(AmfEventTypes.processApiFile, {
+      file,
+    });
+    target.dispatchEvent(e);
+    return (e.detail.result as unknown) as Promise<ApiParseResult>;
+  }
+
+  /**
+   * Informs the UI to select a single file from the list of API entry point candidates.
+   */
+  static async selectApiMainFile(candidates: string[], target: EventTarget = window): Promise<string | undefined> {
+    const e = new ContextEvent(AmfEventTypes.selectApiMainFile, {
+      candidates,
+    });
+    target.dispatchEvent(e);
+    return e.detail.result as Promise<string | undefined>;
+  }
+}

package/src/events/authorization/AuthorizationEvents.ts

@@ -14,22 +14,22 @@ export class AuthorizationEvents {
 
 class OAuth2Events {
   /**
-   * @param target A node on which to dispatch the event.
    * @param config Authorization options.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved with authorization result
    */
-  static async authorize(target: EventTarget, config: IOAuth2Authorization): Promise<ITokenInfo | undefined> {
+  static async authorize(config: IOAuth2Authorization, target: EventTarget = window): Promise<ITokenInfo | undefined> {
     const e = new ContextEvent<IOAuth2Authorization, ITokenInfo>(AuthorizationEventTypes.OAuth2.authorize, config);
     target.dispatchEvent(e);
     return e.detail.result;
   }
 
   /**
-   * @param target A node on which to dispatch the event.
    * @param config Authorization options.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved when the token is removed
    */
-  static async removeToken(target: EventTarget, config: ITokenRemoveOptions): Promise<void> {
+  static async removeToken(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
     const e = new ContextEvent<ITokenRemoveOptions, void>(AuthorizationEventTypes.OAuth2.removeToken, config);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -38,22 +38,22 @@ class OAuth2Events {
 
 class OidcEvents {
   /**
-   * @param target A node on which to dispatch the event.
    * @param config Authorization options.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved with authorization result
    */
-  static async authorize(target: EventTarget, config: IOAuth2Authorization): Promise<(IOidcTokenInfo|IOidcTokenError)[] | undefined> {
+  static async authorize(config: IOAuth2Authorization, target: EventTarget = window): Promise<(IOidcTokenInfo|IOidcTokenError)[] | undefined> {
     const e = new ContextEvent<IOAuth2Authorization, (IOidcTokenInfo|IOidcTokenError)[]>(AuthorizationEventTypes.Oidc.authorize, config);
     target.dispatchEvent(e);
     return e.detail.result;
   }
 
   /**
-   * @param target A node on which to dispatch the event.
    * @param config Authorization options.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved when the token is removed
    */
-  static async removeToken(target: EventTarget, config: ITokenRemoveOptions): Promise<void> {
+  static async removeToken(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
     const e = new ContextEvent<ITokenRemoveOptions, void>(AuthorizationEventTypes.Oidc.removeTokens, config);
     target.dispatchEvent(e);
     return e.detail.result;

package/src/events/cookies/CookieEvents.ts

@@ -48,7 +48,7 @@ export class CookieEvents {
    * @param domain The cookie domain
    * @returns The list of project index objects.
    */
-  static async listDomain(target: EventTarget, domain: string): Promise<IHttpCookie[] | undefined> {
+  static async listDomain(domain: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
     const detail: ICookieDomainListDetail = { domain };
     const e = new ContextEvent<ICookieDomainListDetail, IHttpCookie[]>(CookieEventTypes.listDomain, detail);
     target.dispatchEvent(e);
@@ -60,7 +60,7 @@ export class CookieEvents {
    * @param url The cookie URL
    * @returns The list of project index objects.
    */
-  static async listUrl(target: EventTarget, url: string): Promise<IHttpCookie[] | undefined> {
+  static async listUrl(url: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
     const detail: ICookieUrlListDetail = { url };
     const e = new ContextEvent<ICookieUrlListDetail, IHttpCookie[]>(CookieEventTypes.listUrl, detail);
     target.dispatchEvent(e);
@@ -73,7 +73,7 @@ export class CookieEvents {
    * @param target The target on which to dispatch the event
    * @param cookies The list of cookies to remove
    */
-  static async delete(target: EventTarget, cookies: IHttpCookie[]): Promise<void> {
+  static async delete(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
     const detail: ICookieItemsDetail = { cookies };
     const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.delete, detail);
     target.dispatchEvent(e);
@@ -87,7 +87,7 @@ export class CookieEvents {
    * @param url The url associated with the cookie. Depending on the session mechanism the URL or the domain and the path is used.
    * @param name The name of the cookie to remove. When not set all cookies are removed for the given URL.
    */
-  static async deleteUrl(target: EventTarget, url: string, name?: string): Promise<void> {
+  static async deleteUrl(url: string, name?: string, target: EventTarget = window): Promise<void> {
     const detail: ICookieDeleteUrlDetail = { url, name };
     const e = new ContextEvent<ICookieDeleteUrlDetail, void>(CookieEventTypes.deleteUrl, detail);
     target.dispatchEvent(e);
@@ -101,7 +101,7 @@ export class CookieEvents {
    * @param cookie A cookie to update
    * @returns The change record of the updated cookie.
    */
-  static async update(target: EventTarget, cookie: IHttpCookie): Promise<ContextChangeRecord<IHttpCookie> | undefined> {
+  static async update(cookie: IHttpCookie, target: EventTarget = window): Promise<ContextChangeRecord<IHttpCookie> | undefined> {
     const e = new ContextUpdateEvent(CookieEventTypes.update, { item: cookie });
     target.dispatchEvent(e);
     return e.detail.result;
@@ -114,7 +114,7 @@ export class CookieEvents {
    * @param cookies A list of cookies to update
    * @returns The change record of the updated cookie.
    */
-  static async updateBulk(target: EventTarget, cookies: IHttpCookie[]): Promise<void> {
+  static async updateBulk(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
     const detail: ICookieItemsDetail = { cookies };
     const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.updateBulk, detail);
     target.dispatchEvent(e);
@@ -135,7 +135,7 @@ class StateEvents {
    * @param target The target on which to dispatch the event
    * @param cookie The schema of the removed cookie
    */
-  static delete(target: EventTarget, cookie: IHttpCookie): void {
+  static delete(cookie: IHttpCookie, target: EventTarget = window): void {
     const e = new CustomEvent<ICookieDetail>(CookieEventTypes.State.delete, {
       bubbles: true,
       composed: true,
@@ -150,7 +150,7 @@ class StateEvents {
    * @param target The target on which to dispatch the event
    * @param record The change record.
    */
-  static update(target: EventTarget, record: ContextChangeRecord<IHttpCookie>): void {
+  static update(record: ContextChangeRecord<IHttpCookie>, target: EventTarget = window): void {
     const e = new ContextStateUpdateEvent<IHttpCookie>(CookieEventTypes.State.update, record);
     target.dispatchEvent(e);
   }

package/src/events/encryption/EncryptionEvents.ts

@@ -20,13 +20,13 @@ export class EncryptionEvents {
   /**
    * Dispatches an event handled by the encryption module to encrypt the data
    *
-   * @param target A node on which to dispatch the event.
    * @param data The data to encrypt
    * @param passphrase The passphrase to use in 2-way data encryption
    * @param method Encryption method to use
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the encryption result
    */
-  static async encrypt(target: EventTarget, data: any, passphrase: string, method: string): Promise<string | undefined> {
+  static async encrypt(data: any, passphrase: string, method: string, target: EventTarget = window): Promise<string | undefined> {
     const config: IEncryptionEventDetail = { data, passphrase, method };
     const e = new ContextEvent<IEncryptionEventDetail, string>(EncryptionEventTypes.encrypt, config);
     target.dispatchEvent(e);
@@ -36,13 +36,13 @@ export class EncryptionEvents {
   /**
    * Dispatches an event handled by the encryption module to decrypt the data
    *
-   * @param target A node on which to dispatch the event.
    * @param data The data to decrypt
    * @param passphrase The passphrase to use to decrypt the data
    * @param method Method used to encrypt the data
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the decrypted result
    */
-  static async decrypt(target: EventTarget, data: any, passphrase: string, method: string): Promise<string | undefined> {
+  static async decrypt(data: any, passphrase: string, method: string, target: EventTarget = window): Promise<string | undefined> {
     const config: IEncryptionEventDetail = { data, passphrase, method };
     const e = new ContextEvent<IEncryptionEventDetail, string>(EncryptionEventTypes.decrypt, config);
     target.dispatchEvent(e);

package/src/events/environment/EnvironmentEvents.ts

@@ -10,12 +10,12 @@ export class EnvironmentEvents {
   /**
    * An event dispatched to set a variable in the current environment.
    * 
-   * @param target A node on which to dispatch the event.
    * @param name Variable name
    * @param value Variable value
+   * @param target A node on which to dispatch the event.
    * @returns Nothing. The promise resolves when the variable is set.
    */
-  static async set(target: EventTarget, name: string, value: string): Promise<void> {
+  static async set(name: string, value: string, target: EventTarget = window): Promise<void> {
     const detail: ISetVariableDetail = { name, value };
     const e = new ContextEvent<ISetVariableDetail, void>(EnvironmentEventTypes.set, detail);
     target.dispatchEvent(e);

package/src/events/models/ClientCertificateEvents.ts

@@ -6,11 +6,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to read the client certificate.
    *
-   * @param target A node on which to dispatch the event.
    * @param id The id of the client certificate
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to a client certificate model.
    */
-  static async read(target: EventTarget, id: string): Promise<HttpCertificate | undefined> {
+  static async read(id: string, target: EventTarget = window): Promise<HttpCertificate | undefined> {
     const e = new ContextReadEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.read, id);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -19,11 +19,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event to list the client certificates data.
    *
-   * @param target A node on which to dispatch the event.
    * @param opts Query options.
+   * @param target A node on which to dispatch the event.
    * @returns The list result.
    */
-  static async list(target: EventTarget, opts?: ContextListOptions): Promise<ContextListResult<HttpCertificate> | undefined> {
+  static async list(opts?: ContextListOptions, target: EventTarget = window): Promise<ContextListResult<HttpCertificate> | undefined> {
     const e = new ContextListEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.list, opts);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -32,11 +32,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to delete a client certificate
    *
-   * @param target A node on which to dispatch the event.
    * @param id The id of the project to delete.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to a new revision after delete.
    */
-  static async delete(target: EventTarget, id: string): Promise<ContextDeleteRecord | undefined> {
+  static async delete(id: string, target: EventTarget = window): Promise<ContextDeleteRecord | undefined> {
     const e = new ContextDeleteEvent(ModelEventTypes.ClientCertificate.delete, id, undefined);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -45,11 +45,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to insert a new client certificate.
    *
-   * @param target A node on which to dispatch the event.
    * @param item The certificate object.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the change record
    */
-  static async insert(target: EventTarget, item: ICertificateCreateOptions): Promise<ContextChangeRecord<HttpCertificate> | undefined> {
+  static async insert(item: ICertificateCreateOptions, target: EventTarget = window): Promise<ContextChangeRecord<HttpCertificate> | undefined> {
     const e = new ContextUpdateEvent<ICertificateCreateOptions, HttpCertificate>(ModelEventTypes.ClientCertificate.insert, { item, });
     target.dispatchEvent(e);
     return e.detail.result;
@@ -67,7 +67,7 @@ class StateEvents {
    * @param target A node on which to dispatch the event.
    * @param record Change record
    */
-  static update(target: EventTarget, record: ContextChangeRecord<HttpCertificate>): void {
+  static update(record: ContextChangeRecord<HttpCertificate>, target: EventTarget = window): void {
     const e = new ContextStateUpdateEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.State.update, record);
     target.dispatchEvent(e);
   }
@@ -75,10 +75,10 @@ class StateEvents {
   /**
    * Dispatches an event after a client certificate was deleted
    *
-   * @param target A node on which to dispatch the event.
    * @param record The context store delete record
+   * @param target A node on which to dispatch the event.
    */
-  static delete(target: EventTarget, record: ContextDeleteRecord): void {
+  static delete(record: ContextDeleteRecord, target: EventTarget = window): void {
     const e = new ContextStateDeleteEvent(ModelEventTypes.ClientCertificate.State.delete, record);
     target.dispatchEvent(e);
   }

package/src/events/process/ProcessEvents.ts

@@ -21,11 +21,11 @@ export class ProcessEvents {
    * in the background. The side effect of the event is the UI showing a process
    * indicator.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process. The same id has to be passed to the stop event.
    * @param message Optional message rendered in the UI.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingStart(target: EventTarget, pid: string, message: string): void {
+  static loadingStart(pid: string, message: string, target: EventTarget = window): void {
     const detail: IProcessStartDetail = { pid, message };
     const e = new CustomEvent(ProcessEventTypes.loadingStart, {
       cancelable: true,
@@ -40,10 +40,10 @@ export class ProcessEvents {
    * An event to be dispatched when the application has finished a long running process
    * in the background.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process. The same id has to be passed to the stop event.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingStop(target: EventTarget, pid: string): void {
+  static loadingStop(pid: string, target: EventTarget = window): void {
     const detail: IProcessStopDetail = { pid };
     const e = new CustomEvent(ProcessEventTypes.loadingStop, {
       cancelable: true,
@@ -58,12 +58,12 @@ export class ProcessEvents {
    * An event to be dispatched when the application has finished a long running process
    * in the background with an error.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process used to start it.
    * @param message The message to be rendered to the user.
    * @param error The error object caused the event. Optional.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingError(target: EventTarget, pid: string, message: string, error?: Error): void {
+  static loadingError(pid: string, message: string, error?: Error, target: EventTarget = window): void {
     const detail: IProcessErrorDetail = { pid, message, error };
     const e = new CustomEvent(ProcessEventTypes.loadingError, {
       cancelable: true,

package/src/events/reporting/ReportingEvents.ts

@@ -10,12 +10,12 @@ export class ReportingEvents {
   /**
    * Dispatches the general error event for UI logging purposes.
    * 
-   * @param target A node on which to dispatch the event
    * @param description The error description
    * @param error Optional original error object that has caused this event
    * @param component Optional component name.
+   * @param target A node on which to dispatch the event
    */
-  static error(target: EventTarget, description: string, error?: Error, component?: string): void {
+  static error(description: string, error?: Error, component?: string, target: EventTarget = window): void {
     const detail: IReportingErrorDetail = { error, description, component };
     const e = new CustomEvent(ReportingEventTypes.error, {
       bubbles: true,

package/src/events/telemetry/TelemetryEvents.ts

@@ -48,7 +48,7 @@ export class TelemetryEvents {
    * @param screenName The screen name
    * @param info Analytics base configuration
    */
-  static view(target: EventTarget, screenName: string, info: ITelemetryDetail = {}): void {
+  static view(screenName: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryScreenViewDetail = {
       ...info, screenName,
     };
@@ -66,7 +66,7 @@ export class TelemetryEvents {
    * @param target A node on which to dispatch the event
    * @param detail The event configuration
    */
-  static event(target: EventTarget, detail: ITelemetryEventDetail): void {
+  static event(detail: ITelemetryEventDetail, target: EventTarget = window): void {
     const e = new CustomEvent(TelemetryEventTypes.event, {
       bubbles: true,
       composed: true,
@@ -83,7 +83,7 @@ export class TelemetryEvents {
    * @param fatal Whether the exception was fatal to the application
    * @param info Analytics base configuration
    */
-  static exception(target: EventTarget, description: string, fatal?: boolean, info: ITelemetryDetail = {}): void {
+  static exception(description: string, fatal?: boolean, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryExceptionDetail = { ...info, description, fatal };
     const e = new CustomEvent(TelemetryEventTypes.exception, {
       bubbles: true,
@@ -102,7 +102,7 @@ export class TelemetryEvents {
    * @param url The share url
    * @param info Analytics base configuration
    */
-  static social(target: EventTarget, network: string, action: string, url: string, info: ITelemetryDetail = {}): void {
+  static social(network: string, action: string, url: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetrySocialDetail = { ...info, network, action, target: url };
     const e = new CustomEvent(TelemetryEventTypes.social, {
       bubbles: true,
@@ -122,7 +122,7 @@ export class TelemetryEvents {
    * @param label The timing label
    * @param info Analytics base configuration
    */
-  static timing(target: EventTarget, category: string, variable: string, value: number, label?: string, info: ITelemetryDetail = {}): void {
+  static timing(category: string, variable: string, value: number, label?: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryTimingDetail = { ...info, category, variable, value, label };
     const e = new CustomEvent(TelemetryEventTypes.timing, {
       bubbles: true,
@@ -145,7 +145,7 @@ class StateEvents {
    * 
    * @param target The node on which to dispatch the event.
    */
-  static set(target: EventTarget): void {
+  static set(target: EventTarget = window): void {
     const e = new Event(TelemetryEventTypes.State.set, {
       composed: true,
       cancelable: true,

package/src/events/transport/TransportEvents.ts

@@ -39,7 +39,7 @@ export const TransportEvent = Object.freeze({
      * @param config Optional request configuration.
      * @returns The execution log or `undefined` when the event was not handled.
      */
-    send: async (target: EventTarget, request: IHttpRequest, authorization?: IRequestAuthorization[], config?: IRequestBaseConfig): Promise<IRequestLog | undefined> => {
+    send: async (request: IHttpRequest, authorization?: IRequestAuthorization[], config?: IRequestBaseConfig, target: EventTarget = window): Promise<IRequestLog | undefined> => {
       const e = new ContextEvent<ICoreRequestDetail, IRequestLog>(TransportEventTypes.Core.send, {
         request,
         authorization,
@@ -62,7 +62,7 @@ export const TransportEvent = Object.freeze({
      * @param init Optional request init options compatible with the Fetch API.
      * @returns Compatible with the Fetch API Response object or `undefined` when the event was not handled.
      */
-    send: async (target: EventTarget, request: IHttpRequest, init?: RequestInit): Promise<Response | undefined> => {
+    send: async (request: IHttpRequest, init?: RequestInit, target: EventTarget = window): Promise<Response | undefined> => {
       const e = new ContextEvent<IHttpRequestDetail, Response>(TransportEventTypes.Http.send, {
         request,
         init,
@@ -82,7 +82,7 @@ export const TransportEvent = Object.freeze({
      * @param opts The project execution options.
      * @returns 
      */
-    send: async (target: EventTarget, project: HttpProject | string, opts: IProjectRunnerOptions): Promise<IProjectExecutionLog | undefined> => {
+    send: async (project: HttpProject | string, opts: IProjectRunnerOptions, target: EventTarget = window): Promise<IProjectExecutionLog | undefined> => {
       const e = new ContextEvent<IProjectRequestDetail, IProjectExecutionLog>(TransportEventTypes.Project.send, {
         project,
         opts,

package/src/runtime/actions/runnable/DeleteCookieRunnable.ts

@@ -19,7 +19,7 @@ export class DeleteCookieRunnable extends ActionRunnable {
     if (!url) {
       return;
     }
-    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+    Events.Cookie.deleteUrl(url, config.name, this.eventTarget);
   }
 
   async request(request: IHttpRequest): Promise<void> {
@@ -34,6 +34,6 @@ export class DeleteCookieRunnable extends ActionRunnable {
     if (!url) {
       return;
     }
-    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+    Events.Cookie.deleteUrl(url, config.name, this.eventTarget);
   } 
 }

package/src/runtime/actions/runnable/SetCookieRunnable.ts

@@ -68,7 +68,7 @@ export class SetCookieRunnable extends ActionRunnable {
     if (typeof config.secure === 'boolean') {
       cookie.secure = config.secure;
     }
-    Events.Cookie.update(this.eventTarget, cookie);
+    Events.Cookie.update(cookie, this.eventTarget);
   }
 
   async response(log: IRequestLog): Promise<void> {

package/src/runtime/actions/runnable/SetVariableRunnable.ts

@@ -29,7 +29,7 @@ export class SetVariableRunnable extends ActionRunnable {
 
   async setVariable(config: ISetVariableAction, value: string): Promise<void> {
     const { name } = config;
-    Events.Environment.set(this.eventTarget, name, value);
+    Events.Environment.set(name, value, this.eventTarget);
   }
 
   async response(log: IRequestLog): Promise<void> {

package/src/runtime/modules/RequestCookies.ts

@@ -19,7 +19,7 @@ import { Cookie } from '../../lib/cookies/Cookie.js';
  * @returns A promise that resolves to header value string.
  */
 async function getCookiesHeaderValue(eventsTarget: EventTarget, url: string): Promise<string> {
-  const cookies = await CookieEvents.listUrl(eventsTarget, url);
+  const cookies = await CookieEvents.listUrl(url, eventsTarget);
   if (!cookies || !cookies.length) {
     return '';
   }
@@ -141,6 +141,6 @@ export async function processResponseCookies(log: IRequestLog, context: Executio
   const typedResponse = log.response as IResponse;
   const result = extract(typedResponse, log.request.url, log.redirects);
   if (result.cookies.length) {
-    await CookieEvents.updateBulk(context.eventsTarget, result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()));
+    await CookieEvents.updateBulk(result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()), context.eventsTarget);
   }
 }