coveo.analytics 2.30.56 → 2.32.0

package/src/client/utils.spec.ts

@@ -1,113 +1,128 @@
 import {truncateUrl} from './utils';
 
 describe('utils', () => {
-    describe('truncateUrl', () => {
-        // Note: to obtain a UTF-8 encoded escape sequence, run encodeUriComponent('<value>') in your browser console or NodeJS REPL
-        const URL_PLAIN = 'http://coveo.com/this/is/a/really/long/url/that/will/be/truncated?at=some&arbitrary=point';
+  describe('truncateUrl', () => {
+    // Note: to obtain a UTF-8 encoded escape sequence, run encodeUriComponent('<value>') in your browser console or NodeJS REPL
+    const URL_PLAIN =
+      'http://coveo.com/this/is/a/really/long/url/that/will/be/truncated?at=some&arbitrary=point';
 
-        it.each([[8], [16], [32], [64], [128]])(
-            `truncateUrl('${URL_PLAIN}', %d) truncates to exactly that length`,
-            (limit) => {
-                expect(truncateUrl(URL_PLAIN, limit)).toBe(URL_PLAIN.substring(0, limit));
-            },
-        );
+    it.each([[8], [16], [32], [64], [128]])(
+      `truncateUrl('${URL_PLAIN}', %d) truncates to exactly that length`,
+      (limit) => {
+        expect(truncateUrl(URL_PLAIN, limit)).toBe(URL_PLAIN.substring(0, limit));
+      }
+    );
 
-        /** Decoded: `'http://test/ ¿OKツ😅#fine'` */
-        const URL_WITH_ESCAPES = 'http://test/%20%C2%BFOK%E3%83%84%F0%9F%98%85#fine';
-        // Number of bytes in code-point:     <1>< 2  >  <   3   ><    4     >
+    /** Decoded: `'http://test/ ¿OKツ😅#fine'` */
+    const URL_WITH_ESCAPES = 'http://test/%20%C2%BFOK%E3%83%84%F0%9F%98%85#fine';
+    // Number of bytes in code-point:     <1>< 2  >  <   3   ><    4     >
 
-        it.each([[7], [22], [45], [46], [47], [48], [100]])(
-            `truncateUrl('${URL_WITH_ESCAPES}', %d) truncates to the exact limit outside of codepoints`,
-            (limit) => {
-                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, limit));
-            },
-        );
+    it.each([[7], [22], [45], [46], [47], [48], [100]])(
+      `truncateUrl('${URL_WITH_ESCAPES}', %d) truncates to the exact limit outside of codepoints`,
+      (limit) => {
+        expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, limit));
+      }
+    );
 
-        it.each([
-            [12, 12],
-            [13, 12],
-            [14, 12],
-            [15, 15],
-        ])(
-            `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up single-byte codepoints`,
-            (limit, expectedLength) => {
-                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
-            },
+    it.each([
+      [12, 12],
+      [13, 12],
+      [14, 12],
+      [15, 15],
+    ])(
+      `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up single-byte codepoints`,
+      (limit, expectedLength) => {
+        expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(
+          URL_WITH_ESCAPES.substring(0, expectedLength)
         );
+      }
+    );
 
-        it.each([
-            [15, 15],
-            [16, 15],
-            [17, 15],
-            [18, 15],
-            [19, 15],
-            [20, 15],
-            [21, 21],
-        ])(`truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up two-byte codepoints`, (limit, expectedLength) => {
-            expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
-        });
+    it.each([
+      [15, 15],
+      [16, 15],
+      [17, 15],
+      [18, 15],
+      [19, 15],
+      [20, 15],
+      [21, 21],
+    ])(
+      `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up two-byte codepoints`,
+      (limit, expectedLength) => {
+        expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(
+          URL_WITH_ESCAPES.substring(0, expectedLength)
+        );
+      }
+    );
 
-        it.each([
-            [23, 23],
-            [24, 23],
-            [25, 23],
-            [26, 23],
-            [27, 23],
-            [28, 23],
-            [29, 23],
-            [30, 23],
-            [31, 23],
-            [32, 32],
-        ])(
-            `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up three-byte codepoints`,
-            (limit, expectedLength) => {
-                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
-            },
+    it.each([
+      [23, 23],
+      [24, 23],
+      [25, 23],
+      [26, 23],
+      [27, 23],
+      [28, 23],
+      [29, 23],
+      [30, 23],
+      [31, 23],
+      [32, 32],
+    ])(
+      `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up three-byte codepoints`,
+      (limit, expectedLength) => {
+        expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(
+          URL_WITH_ESCAPES.substring(0, expectedLength)
         );
+      }
+    );
 
-        it.each([
-            [32, 32],
-            [33, 32],
-            [34, 32],
-            [35, 32],
-            [36, 32],
-            [37, 32],
-            [38, 32],
-            [39, 32],
-            [40, 32],
-            [41, 32],
-            [42, 32],
-            [43, 32],
-            [44, 44],
-        ])(`truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up four-byte codepoints`, (limit, expectedLength) => {
-            expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
-        });
+    it.each([
+      [32, 32],
+      [33, 32],
+      [34, 32],
+      [35, 32],
+      [36, 32],
+      [37, 32],
+      [38, 32],
+      [39, 32],
+      [40, 32],
+      [41, 32],
+      [42, 32],
+      [43, 32],
+      [44, 44],
+    ])(
+      `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up four-byte codepoints`,
+      (limit, expectedLength) => {
+        expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(
+          URL_WITH_ESCAPES.substring(0, expectedLength)
+        );
+      }
+    );
 
-        const URL_WITH_INVALID_ESCAPES = 'http://test/%this%is%so%invalid';
+    const URL_WITH_INVALID_ESCAPES = 'http://test/%this%is%so%invalid';
 
-        it.each([
-            [12, 12],
-            [13, 12],
-            [14, 12],
-            [15, 15],
-            [16, 16],
-            [17, 17],
-            [18, 17],
-            [19, 17],
-            [20, 20],
-            [21, 20],
-            [22, 20],
-            [23, 23],
-            [24, 23],
-            [25, 23],
-            [26, 26],
-        ])(
-            `truncateUrl('${URL_WITH_INVALID_ESCAPES}', %d) only checks for percent with invalid escapes`,
-            (limit, expectedLength) => {
-                expect(truncateUrl(URL_WITH_INVALID_ESCAPES, limit)).toBe(
-                    URL_WITH_INVALID_ESCAPES.substring(0, expectedLength),
-                );
-            },
+    it.each([
+      [12, 12],
+      [13, 12],
+      [14, 12],
+      [15, 15],
+      [16, 16],
+      [17, 17],
+      [18, 17],
+      [19, 17],
+      [20, 20],
+      [21, 20],
+      [22, 20],
+      [23, 23],
+      [24, 23],
+      [25, 23],
+      [26, 26],
+    ])(
+      `truncateUrl('${URL_WITH_INVALID_ESCAPES}', %d) only checks for percent with invalid escapes`,
+      (limit, expectedLength) => {
+        expect(truncateUrl(URL_WITH_INVALID_ESCAPES, limit)).toBe(
+          URL_WITH_INVALID_ESCAPES.substring(0, expectedLength)
         );
-    });
+      }
+    );
+  });
 });

package/src/client/utils.ts

@@ -2,7 +2,7 @@
 // see https://github.com/microsoft/TypeScript/pull/12253#issuecomment-393954723
 export const keysOf = Object.keys as <T>(o: T) => Extract<keyof T, string>[];
 export function isObject(o: any): boolean {
-    return o !== null && typeof o === 'object' && !Array.isArray(o);
+  return o !== null && typeof o === 'object' && !Array.isArray(o);
 }
 
 /**
@@ -13,7 +13,7 @@ export function isObject(o: any): boolean {
  * @returns The input, possibly coerced to a number.
  */
 export function coerceToNumber(input: any): any {
-    return typeof input === 'string' && input != '' && !Number.isNaN(+input) ? +input : input;
+  return typeof input === 'string' && input != '' && !Number.isNaN(+input) ? +input : input;
 }
 
 /**
@@ -29,16 +29,16 @@ const UTF8_HEADER_3 = 0b1110_0000;
 const UTF8_HEADER_4 = 0b1111_0000;
 
 function utf8ByteCountFromFirstByte(firstByte: number): number {
-    if ((firstByte & 0b1111_1000) === UTF8_HEADER_4) {
-        return 4;
-    }
-    if ((firstByte & UTF8_HEADER_4) === UTF8_HEADER_3) {
-        return 3;
-    }
-    if ((firstByte & UTF8_HEADER_3) === UTF8_HEADER_2) {
-        return 2;
-    }
-    return 1;
+  if ((firstByte & 0b1111_1000) === UTF8_HEADER_4) {
+    return 4;
+  }
+  if ((firstByte & UTF8_HEADER_4) === UTF8_HEADER_3) {
+    return 3;
+  }
+  if ((firstByte & UTF8_HEADER_3) === UTF8_HEADER_2) {
+    return 2;
+  }
+  return 1;
 }
 
 /**
@@ -49,34 +49,34 @@ function utf8ByteCountFromFirstByte(firstByte: number): number {
  * @returns The URL, possibly truncated to a length near limit (at most 11 characters less than limit).
  */
 export function truncateUrl(input: string, limit: number): string {
-    if (limit < 0 || input.length <= limit) {
-        return input;
+  if (limit < 0 || input.length <= limit) {
+    return input;
+  }
+  // A valid escape sequence is a percent followed by 2 hexadecimal characters; check if we split one up.
+  let end = input.indexOf('%', limit - 2);
+  if (end < 0 || end > limit) {
+    end = limit;
+  } else {
+    limit = end;
+  }
+  // Check that truncating at end won't break up an UTF-8 multibyte sequence half-way,
+  // by peeking backwards to find the first byte of an UTF-8 sequence (if present).
+  while (end > 2 && input.charAt(end - 3) == '%') {
+    const peekByte = Number.parseInt(input.substring(end - 2, end), 16);
+    // Note: if parsing fails, NaN gets coerced to 0 by the bitwise and.
+    if ((peekByte & UTF8_HIGH_BIT) != UTF8_HIGH_BIT) {
+      break;
     }
-    // A valid escape sequence is a percent followed by 2 hexadecimal characters; check if we split one up.
-    let end = input.indexOf('%', limit - 2);
-    if (end < 0 || end > limit) {
+    end -= 3;
+    // Check if we reached the first byte by checking it is not a "follow byte": 10xx_xxxx.
+    if ((peekByte & UTF8_HEADER_2) != UTF8_HIGH_BIT) {
+      // If the full code point is there, keep it.
+      if (limit - end >= utf8ByteCountFromFirstByte(peekByte) * 3) {
         end = limit;
-    } else {
-        limit = end;
-    }
-    // Check that truncating at end won't break up an UTF-8 multibyte sequence half-way,
-    // by peeking backwards to find the first byte of an UTF-8 sequence (if present).
-    while (end > 2 && input.charAt(end - 3) == '%') {
-        const peekByte = Number.parseInt(input.substring(end - 2, end), 16);
-        // Note: if parsing fails, NaN gets coerced to 0 by the bitwise and.
-        if ((peekByte & UTF8_HIGH_BIT) != UTF8_HIGH_BIT) {
-            break;
-        }
-        end -= 3;
-        // Check if we reached the first byte by checking it is not a "follow byte": 10xx_xxxx.
-        if ((peekByte & UTF8_HEADER_2) != UTF8_HIGH_BIT) {
-            // If the full code point is there, keep it.
-            if (limit - end >= utf8ByteCountFromFirstByte(peekByte) * 3) {
-                end = limit;
-            }
-            // Otherwise, end is already set at the correct point to truncate at (the start of the multibyte sequence).
-            break;
-        }
+      }
+      // Otherwise, end is already set at the correct point to truncate at (the start of the multibyte sequence).
+      break;
     }
-    return input.substring(0, end);
+  }
+  return input.substring(0, end);
 }

package/src/cookieutils.spec.ts

@@ -0,0 +1,59 @@
+import {vi} from 'vitest';
+import {Cookie} from './cookieutils';
+
+describe('Cookie', () => {
+  const originalLocation = window.location;
+
+  const captureCookieWrite = (protocol: string, hostname: string) => {
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: {...originalLocation, protocol, hostname},
+    });
+    const writes: string[] = [];
+    vi.spyOn(document, 'cookie', 'set').mockImplementation((value: string) => {
+      writes.push(value);
+    });
+    return writes;
+  };
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: originalLocation,
+    });
+  });
+
+  it('adds the Secure attribute when the page is served over https', () => {
+    const writes = captureCookieWrite('https:', 'localhost');
+
+    Cookie.set('testCookie', 'testValue');
+
+    expect(writes[0]).toBe('testCookie=testValue;path=/;SameSite=Lax;Secure');
+  });
+
+  it('omits the Secure attribute when the page is served over http', () => {
+    const writes = captureCookieWrite('http:', 'localhost');
+
+    Cookie.set('testCookie', 'testValue');
+
+    expect(writes[0]).toBe('testCookie=testValue;path=/;SameSite=Lax');
+  });
+
+  it('keeps the domain attribute alongside Secure over https', () => {
+    const writes = captureCookieWrite('https:', 'subdomain.example.com');
+
+    Cookie.set('testCookie', 'testValue');
+
+    expect(writes[0]).toBe('testCookie=testValue;domain=example.com;path=/;SameSite=Lax;Secure');
+  });
+
+  it('keeps the expiration attribute alongside Secure over https', () => {
+    const writes = captureCookieWrite('https:', 'localhost');
+
+    Cookie.set('testCookie', 'testValue', 3600000);
+
+    expect(writes[0]).toContain('expires=');
+    expect(writes[0]).toContain(';path=/;SameSite=Lax;Secure');
+  });
+});

package/src/cookieutils.ts

@@ -1,52 +1,53 @@
 interface CookieDetails {
-    name: string;
-    value: string;
-    expirationDate?: Date;
-    domain?: string;
+  name: string;
+  value: string;
+  expirationDate?: Date;
+  domain?: string;
 }
 
 // Code originally modified from : https://developers.livechatinc.com/blog/setting-cookies-to-subdomains-in-javascript/
 export class Cookie {
-    static set(name: string, value: string, expire?: number) {
-        var domain: string, expirationDate: Date | undefined, domainParts: string[], host: string;
-        if (expire) {
-            expirationDate = new Date();
-            expirationDate.setTime(expirationDate.getTime() + expire);
-        }
-        host = window.location.hostname;
-        if (host.indexOf('.') === -1) {
-            // no "." in a domain - single domain name, it's localhost or something similar
-            writeCookie(name, value, expirationDate);
-        } else {
-            domainParts = host.split('.');
-            // we always have at least 2 domain parts
-            domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
-            writeCookie(name, value, expirationDate, domain);
-        }
+  static set(name: string, value: string, expire?: number) {
+    var domain: string, expirationDate: Date | undefined, domainParts: string[], host: string;
+    if (expire) {
+      expirationDate = new Date();
+      expirationDate.setTime(expirationDate.getTime() + expire);
     }
-
-    static get(name: string) {
-        var cookiePrefix = name + '=';
-        var cookieArray = document.cookie.split(';');
-        for (var i = 0; i < cookieArray.length; i++) {
-            var cookie = cookieArray[i];
-            cookie = cookie.replace(/^\s+/, ''); //strip whitespace from front of cookie only
-            if (cookie.lastIndexOf(cookiePrefix, 0) === 0) {
-                return cookie.substring(cookiePrefix.length, cookie.length);
-            }
-        }
-        return null;
+    host = window.location.hostname;
+    if (host.indexOf('.') === -1) {
+      // no "." in a domain - single domain name, it's localhost or something similar
+      writeCookie(name, value, expirationDate);
+    } else {
+      domainParts = host.split('.');
+      // we always have at least 2 domain parts
+      domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
+      writeCookie(name, value, expirationDate, domain);
     }
+  }
 
-    static erase(name: string) {
-        Cookie.set(name, '', -1);
+  static get(name: string) {
+    var cookiePrefix = name + '=';
+    var cookieArray = document.cookie.split(';');
+    for (var i = 0; i < cookieArray.length; i++) {
+      var cookie = cookieArray[i];
+      cookie = cookie.replace(/^\s+/, ''); //strip whitespace from front of cookie only
+      if (cookie.lastIndexOf(cookiePrefix, 0) === 0) {
+        return cookie.substring(cookiePrefix.length, cookie.length);
+      }
     }
+    return null;
+  }
+
+  static erase(name: string) {
+    Cookie.set(name, '', -1);
+  }
 }
 
 function writeCookie(name: string, value: string, expirationDate?: Date, domain?: string) {
-    document.cookie =
-        `${name}=${value}` +
-        (expirationDate ? `;expires=${expirationDate.toUTCString()}` : '') +
-        (domain ? `;domain=${domain}` : '') +
-        ';path=/;SameSite=Lax';
+  document.cookie =
+    `${name}=${value}` +
+    (expirationDate ? `;expires=${expirationDate.toUTCString()}` : '') +
+    (domain ? `;domain=${domain}` : '') +
+    ';path=/;SameSite=Lax' +
+    (window.location.protocol === 'https:' ? ';Secure' : '');
 }

package/src/coveoua/browser.ts

@@ -5,23 +5,23 @@ declare const self: any;
 
 const promise = (window as any)['Promise'];
 if (!(promise instanceof Function) && !global) {
-    console.error(
-        `This script uses window.Promise which is not supported in your browser. Consider adding a polyfill like "es6-promise".`,
-    );
+  console.error(
+    `This script uses window.Promise which is not supported in your browser. Consider adding a polyfill like "es6-promise".`
+  );
 }
 const fetch = (window as any)['fetch'];
 if (!(fetch instanceof Function) && !global) {
-    console.error(
-        `This script uses window.fetch which is not supported in your browser. Consider adding a polyfill like "fetch".`,
-    );
+  console.error(
+    `This script uses window.fetch which is not supported in your browser. Consider adding a polyfill like "fetch".`
+  );
 }
 
 // CoveoUAGlobal is the interface for the global function which also has a
 // queue `q` of unexecuted parameters
 export interface CoveoUAGlobal {
-    (action: string, ...params: any[]): void;
-    // CoveoAnalytics.q is the queue of last called actions before lib was included
-    q?: [string, any[]][];
+  (action: string, ...params: any[]): void;
+  // CoveoAnalytics.q is the queue of last called actions before lib was included
+  q?: [string, any[]][];
 }
 
 // On load of this script we get the global object `coveoua` (which would be)
@@ -36,9 +36,11 @@ self.coveoanalytics = analytics;
 // On normal execution this library should be loaded after the snippet execution
 // so we will execute the actions in the `q` array
 if (coveoua.q) {
-    const initEvents = coveoua.q.filter((args: [string, any[]]) => args[0] === 'init');
-    const otherEvents = coveoua.q.filter((args: [string, any[]]) => args[0] !== 'init');
-    [...initEvents, ...otherEvents].forEach((args: [string, any[]]) => handleOneAnalyticsEvent.apply(void 0, args));
+  const initEvents = coveoua.q.filter((args: [string, any[]]) => args[0] === 'init');
+  const otherEvents = coveoua.q.filter((args: [string, any[]]) => args[0] !== 'init');
+  [...initEvents, ...otherEvents].forEach((args: [string, any[]]) =>
+    handleOneAnalyticsEvent.apply(void 0, args)
+  );
 }
 
 export default self.coveoua;

package/src/coveoua/library.ts

@@ -8,10 +8,10 @@ export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export {IRuntimeEnvironment} from '../client/runtimeEnvironment';
 export {CoveoUA, getCurrentClient, handleOneAnalyticsEvent} from './simpleanalytics';
 export {
-    CoveoSearchPageClient,
-    SearchPageClientProvider,
-    EventDescription,
-    EventBuilder,
+  CoveoSearchPageClient,
+  SearchPageClientProvider,
+  EventDescription,
+  EventBuilder,
 } from '../searchPage/searchPageClient';
 export {CaseAssistClient, CaseAssistClientProvider} from '../caseAssist/caseAssistClient';
 export {CoveoInsightClient, InsightClientProvider} from '../insight/insightClient';

package/src/coveoua/plugins.ts

@@ -4,44 +4,46 @@ import {Link} from '../plugins/link';
 import {SVC} from '../plugins/svc';
 
 export class Plugins {
-    public static readonly DefaultPlugins: string[] = [EC.Id, SVC.Id, Link.Id];
-    private registeredPluginsMap: Record<string, PluginClass> = {
-        [EC.Id]: EC,
-        [SVC.Id]: SVC,
-        [Link.Id]: Link,
-    };
-    private requiredPlugins: Record<string, BasePlugin> = {};
+  public static readonly DefaultPlugins: string[] = [EC.Id, SVC.Id, Link.Id];
+  private registeredPluginsMap: Record<string, PluginClass> = {
+    [EC.Id]: EC,
+    [SVC.Id]: SVC,
+    [Link.Id]: Link,
+  };
+  private requiredPlugins: Record<string, BasePlugin> = {};
 
-    require(name: string, options: PluginOptions): void {
-        const pluginClass = this.registeredPluginsMap[name];
-        if (!pluginClass) {
-            throw new Error(
-                `No plugin named "${name}" is currently registered. If you use a custom plugin, use 'provide' first.`,
-            );
-        }
-        this.requiredPlugins[name] = new (pluginClass as any)(options);
+  require(name: string, options: PluginOptions): void {
+    const pluginClass = this.registeredPluginsMap[name];
+    if (!pluginClass) {
+      throw new Error(
+        `No plugin named "${name}" is currently registered. If you use a custom plugin, use 'provide' first.`
+      );
     }
+    this.requiredPlugins[name] = new (pluginClass as any)(options);
+  }
 
-    provide(name: string, plugin: PluginClass) {
-        this.registeredPluginsMap[name] = plugin;
-    }
+  provide(name: string, plugin: PluginClass) {
+    this.registeredPluginsMap[name] = plugin;
+  }
 
-    clearRequired(): void {
-        this.requiredPlugins = {};
-    }
+  clearRequired(): void {
+    this.requiredPlugins = {};
+  }
 
-    execute(name: string, fn: string, ...args: any[]): any {
-        const plugin = this.requiredPlugins[name] as Plugin;
-        if (!plugin) {
-            throw new Error(`The plugin "${name}" is not required. Check that you required it on initialization.`);
-        }
-        const actionFunction = plugin.getApi(fn);
-        if (!actionFunction) {
-            throw new Error(`The function "${fn}" does not exist on the plugin "${name}".`);
-        }
-        if (typeof actionFunction !== 'function') {
-            throw new Error(`"${fn}" of the plugin "${name}" is not a function.`);
-        }
-        return actionFunction.apply(plugin, args);
+  execute(name: string, fn: string, ...args: any[]): any {
+    const plugin = this.requiredPlugins[name] as Plugin;
+    if (!plugin) {
+      throw new Error(
+        `The plugin "${name}" is not required. Check that you required it on initialization.`
+      );
+    }
+    const actionFunction = plugin.getApi(fn);
+    if (!actionFunction) {
+      throw new Error(`The function "${fn}" does not exist on the plugin "${name}".`);
+    }
+    if (typeof actionFunction !== 'function') {
+      throw new Error(`"${fn}" of the plugin "${name}" is not a function.`);
     }
+    return actionFunction.apply(plugin, args);
+  }
 }