@wxcc-desktop/sdk 1.2.6 → 1.2.10

package/src/jsapi/config-jsapi.test.ts

@@ -1,78 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { ConfigJsApi, createConfigJsApi } from "./config-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      }
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("Config JSAPI", () => {
-  let config: ConfigJsApi;
-
-  beforeEach(() => {
-    config = createConfigJsApi(SERVICE);
-
-    // deferred service mock init
-    setTimeout(() => (SERVICE as AgentxServices).init("fake-token"));
-  });
-
-  it("creates", () => {
-    expect(config).toBeDefined();
-    expect(config["logger"]).toBeDefined();
-  });
-
-  it("inits", async () => {
-    let isInited = false;
-    const listener = () => {
-      isInited = true;
-      config.removeEventListener("inited", listener);
-    };
-    config.addEventListener("inited", listener);
-
-    await config.init();
-
-    expect(isInited).toBeTruthy();
-  });
-
-  it("cleanups", async () => {
-    await config.init();
-
-    let isCleaned = false;
-    const listener = () => {
-      isCleaned = true;
-      config.removeEventListener("cleaned", listener);
-    };
-    config.addEventListener("cleaned", listener);
-
-    config.cleanup();
-
-    expect(isCleaned).toBeTruthy();
-  });
-
-  it("gets client locale", async () => {
-    const windowNavigatorLanguagesMock = jest.spyOn(window.navigator, "language", "get");
-    windowNavigatorLanguagesMock.mockReturnValue("en-US");
-
-    expect(config.clientLocale).toBe("en-US");
-  });
-
-  it("waits", async () => {
-    let waiter = false;
-    const waitCb = () => {
-      return waiter;
-    };
-
-    setTimeout(() => (waiter = true));
-
-    await config["waitUntil"](() => waitCb());
-
-    expect(waiter).toBeTruthy();
-  });
-});

package/src/jsapi/config-jsapi.ts

@@ -1,106 +0,0 @@
-import { AgentxService } from "@wxcc-desktop/sdk-types";
-import EventEmitter from "event-emitter";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-
-const SERVICE_INITED_CHECK_TIMEOUT = 1000 / 30;
-
-type Listeners = {
-  //
-  inited: () => void; // Fires after Desktop.config.init(...)
-  cleaned: () => void; // Fires after Desktop.config.cleanup(...)
-};
-type Events = keyof Listeners;
-
-export class ConfigJsApi {
-  private readonly emitter = EventEmitter();
-
-  private readonly logger: ReturnType<typeof createJsApiLogger>;
-
-  private agentxSERVICE?: AgentxService;
-
-  private async waitUntil(cb: () => boolean) {
-    if (typeof cb === "function") {
-      /// Delay
-      await new Promise(resolve => setTimeout(resolve, SERVICE_INITED_CHECK_TIMEOUT));
-
-      // Check
-      const res = cb();
-      // Iterate
-      !res && (await this.waitUntil(cb));
-    }
-  }
-
-  constructor(config: { logger: ReturnType<typeof createJsApiLogger>; SERVICE: AgentxService }) {
-    this.logger = config.logger;
-    this.agentxSERVICE = config.SERVICE;
-  }
-
-  private async checkService(SERVICE: AgentxService) {
-    if (SERVICE) {
-      if (!SERVICE.isInited) {
-        this.logger.warn("SERVICE is not inited. Awaiting it's initAgentxServices(...)...");
-
-        // Awaiting service becomes inited
-        await this.waitUntil(() => SERVICE!.isInited);
-      }
-
-      this.logger.info("SERVICE is inited. Continuing...");
-
-      // Notify all => config ready
-      this.emit("inited");
-      //
-    } else {
-      this.logger.error("SERVICE is not defiend...");
-    }
-  }
-
-  private emit<T extends Events>(eventName: T, ...args: Parameters<Listeners[T]>) {
-    this.emitter.emit(eventName, ...args);
-  }
-
-  async init() {
-    /**
-     * WARNING! Temporary injecting SERVICE into constructor via global object
-     */
-    if (this.agentxSERVICE) {
-      await this.checkService(this.agentxSERVICE);
-    } else {
-      this.logger.error("SERVICE is not defined...");
-    }
-  }
-
-  cleanup() {
-    this.agentxSERVICE = undefined;
-
-    // Notify all => config cleaned
-    this.emit("cleaned");
-
-    this.logger.info(`Cleaned`);
-  }
-
-  get clientLocale() {
-    if (window.navigator.languages != undefined) {
-      return window.navigator.languages[0];
-    }
-    return window.navigator.language;
-  }
-
-  // Events
-  addEventListener<T extends Events>(eventName: T, listener: Listeners[T]) {
-    this.emitter.on(eventName, listener);
-  }
-
-  removeEventListener<T extends Events>(eventName: T, listener: Listeners[T]) {
-    this.emitter.off(eventName, listener);
-  }
-}
-
-const configJsApiLogger = createJsApiLogger(logger, "[Config JSAPI] =>");
-
-// Standalone init
-export const createConfigJsApi = (SERVICE: AgentxService) =>
-  new ConfigJsApi({
-    logger: configJsApiLogger,
-    SERVICE
-  });

package/src/jsapi/dialer-jsapi.test.ts

@@ -1,101 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createDialerJsApi } from "./dialer-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      },
-      aqm: ({
-        dialer: {
-          startOutdial: jest.fn().mockImplementation(async p => p),
-          updateCadVariables: jest.fn().mockImplementation(async p => p),
-          eOutdialFailed: {
-            listen: jest.fn(),
-            listenOnce: jest.fn()
-          }
-        }
-      } as unknown) as AgentxServices["aqm"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("Dialer JSAPI", () => {
-  let dialer: ReturnType<typeof createDialerJsApi>;
-
-  beforeEach(() => {
-    (SERVICE as AgentxServices).init("fake-token");
-
-    dialer = createDialerJsApi();
-
-    dialer.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(dialer).toBeDefined();
-    expect(dialer["logger"]).toBeDefined();
-    expect(dialer["serviceChecker"]).toBeDefined();
-    expect(dialer["aqmEvents"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(dialer["checkService"]()).toBeTruthy();
-    expect(dialer["aqmEvents"].isInited).toBeTruthy();
-  });
-
-  it("checks service", () => {
-    dialer["serviceChecker"].check = jest.fn();
-    dialer["checkService"]();
-
-    expect(dialer["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("calls", async () => {
-    const r = { test: "TEST" } as any;
-
-    {
-      const p = await dialer.startOutdial(r);
-      expect(SERVICE.aqm.dialer.startOutdial).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await dialer.updateCadVariables(r);
-      expect(SERVICE.aqm.dialer.updateCadVariables).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-  });
-
-  it("listens", () => {
-    const listener = () => {};
-    dialer.addEventListener("eOutdialFailed", listener);
-    expect(dialer["aqmEvents"]["listeners"].size).toBe(1);
-    expect(SERVICE.aqm.dialer.eOutdialFailed.listen).toHaveBeenCalledWith(listener);
-    dialer.removeEventListener("eOutdialFailed", listener);
-    expect(dialer["aqmEvents"]["listeners"].size).toBe(0);
-  });
-
-  it("listensOnce", () => {
-    const listener = () => {};
-    dialer.addOnceEventListener("eOutdialFailed", listener);
-    expect(dialer["aqmEvents"]["listenersOnce"].size).toBe(1);
-    expect(SERVICE.aqm.dialer.eOutdialFailed.listenOnce).toHaveBeenCalledWith(listener);
-    dialer.removeOnceEventListener("eOutdialFailed", listener);
-    expect(dialer["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-
-  it("removesAllListeners", () => {
-    const listener1 = () => {};
-    const listener2 = () => {};
-    dialer.addEventListener("eOutdialFailed", listener1);
-    dialer.addOnceEventListener("eOutdialFailed", listener2);
-    expect(dialer["aqmEvents"]["listeners"].size).toBe(1);
-    expect(dialer["aqmEvents"]["listenersOnce"].size).toBe(1);
-    dialer.removeAllEventListeners();
-    expect(dialer["aqmEvents"]["listeners"].size).toBe(0);
-    expect(dialer["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-});

package/src/jsapi/dialer-jsapi.ts

@@ -1,116 +0,0 @@
-import { AgentxService, Service } from "@wxcc-desktop/sdk-types";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-import { createServiceChecker } from "./common/_service-checker";
-import { AqmServiceEntityEvents, createServiceEvents } from "./common/_service-events";
-
-type Listeners = {
-  eOutdialFailed: Parameters<AgentxService["aqm"]["dialer"]["eOutdialFailed"]["listen"]>[0];
-};
-
-type AqmDialerEvents = AqmServiceEntityEvents<Listeners>;
-
-type Config = {
-  logger: ReturnType<typeof createJsApiLogger>;
-  serviceChecker: ReturnType<typeof createServiceChecker>;
-  aqmEvents: AqmDialerEvents;
-};
-
-export class DialerJsApi {
-  private readonly logger: Config["logger"];
-  private readonly serviceChecker: Config["serviceChecker"];
-  private readonly aqmEvents: Config["aqmEvents"];
-
-  private SERVICE?: AgentxService;
-
-  private checkService() {
-    return this.serviceChecker.check(this.SERVICE);
-  }
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-    this.aqmEvents = config.aqmEvents;
-    this.serviceChecker = config.serviceChecker;
-  }
-
-  //
-  init(SERVICE?: AgentxService) {
-    if (SERVICE) {
-      this.SERVICE = SERVICE;
-    }
-
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.aqmEvents.init({
-      aqmServiceEntity: this.SERVICE!.aqm.dialer,
-      aqmServiceEntityString: "SERVICE.aqm.dialer"
-    });
-
-    this.logger.info("Inited");
-  }
-
-  cleanup() {
-    this.aqmEvents.cleanup();
-
-    this.SERVICE = undefined;
-
-    this.logger.info("Cleaned");
-  }
-
-  // data calls
-  async startOutdial(p: { data: Service.Aqm.Dialer.tasks }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.dialer.startOutdial(p);
-  }
-
-  async updateCadVariables(p: { interactionId: string; data: Service.Aqm.Dialer.updateCadPayLoad }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.dialer.updateCadVariables(p);
-  }
-
-  // data events
-  addEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.aqmEvents.addEventListener(eventName, listener);
-  }
-
-  addOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.aqmEvents.addOnceEventListener(eventName, listener);
-  }
-
-  removeEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    this.aqmEvents.removeEventListener(eventName, listener);
-  }
-
-  removeOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    this.aqmEvents.removeOnceEventListener(eventName, listener);
-  }
-
-  removeAllEventListeners() {
-    this.aqmEvents.removeAllEventListeners();
-  }
-}
-
-const dialerJsApiLogger = createJsApiLogger(logger, "[Dialer JSAPI] =>");
-const aqmServiceDialerJsApiLogger = createJsApiLogger(dialerJsApiLogger, "[AqmServiceEvents: Dialer] =>");
-
-// Standalone init
-export const createDialerJsApi = () =>
-  new DialerJsApi({
-    logger: dialerJsApiLogger,
-    aqmEvents: createServiceEvents<Listeners>({
-      logger: aqmServiceDialerJsApiLogger
-    }),
-    serviceChecker: createServiceChecker({ logger: dialerJsApiLogger })
-  });

package/src/jsapi/i18n-jsapi.test.ts

@@ -1,62 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createI18NJsApi } from "./i18n-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: true,
-      i18n: ({
-        DEFAULT_INIT_OPTIONS: {
-          TEST: true
-        }
-      } as unknown) as AgentxServices["i18n"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("I18n", () => {
-  let i18n: ReturnType<typeof createI18NJsApi>;
-  beforeEach(() => {
-    i18n = createI18NJsApi();
-    i18n.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(i18n).toBeDefined();
-    expect(i18n["logger"]).toBeDefined();
-    expect(i18n["serviceChecker"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(i18n["checkService"]()).toBeTruthy();
-  });
-
-  it("checks service", () => {
-    i18n["serviceChecker"].check = jest.fn();
-    i18n["checkService"]();
-
-    expect(i18n["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("creates i18next instance", () => {
-    const i18next = i18n.createInstance();
-
-    expect(i18next).toBeDefined();
-  });
-
-  it("creates mixin instance", () => {
-    const i18next = i18n.createInstance();
-    const i18nMixin = i18n.createMixin({ i18n: i18next });
-
-    expect(i18nMixin).toBeDefined();
-  });
-
-  it("gets default options", () => {
-    expect(i18n.DEFAULT_INIT_OPTIONS).toEqual({ TEST: true });
-  });
-
-  it("merges init options", () => {
-    expect(i18n.getMergedInitOptions({ debug: true }, { lng: "en-US" })).toEqual({ debug: true, lng: "en-US" });
-  });
-});

package/src/jsapi/i18n-jsapi.ts

@@ -1,77 +0,0 @@
-import { I18N } from "@uuip/unified-ui-platform-sdk";
-import { AgentxService } from "@wxcc-desktop/sdk-types";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-import { createServiceChecker } from "./common/_service-checker";
-
-type Config = {
-  logger: ReturnType<typeof createJsApiLogger>;
-  serviceChecker: ReturnType<typeof createServiceChecker>;
-};
-
-export class I18NJsApi {
-  private readonly logger: Config["logger"];
-
-  private readonly serviceChecker: Config["serviceChecker"];
-
-  private SERVICE?: AgentxService;
-
-  private checkService() {
-    return this.serviceChecker.check(this.SERVICE);
-  }
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-    this.serviceChecker = config.serviceChecker;
-  }
-
-  init(SERVICE?: AgentxService) {
-    if (SERVICE) {
-      this.SERVICE = SERVICE;
-    }
-
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.logger.info("Inited");
-  }
-
-  cleanup() {
-    this.SERVICE = undefined;
-
-    this.logger.info("Cleaned");
-  }
-
-  // i18next instance
-  createInstance(createServiceOptions?: I18N.CreateServiceOptions) {
-    return I18N.createService(createServiceOptions);
-  }
-
-  // i18next instance powered LitElement mixin
-  createMixin(createMixinOptions: I18N.CreateMixinOptions) {
-    return I18N.createMixin(createMixinOptions);
-  }
-
-  get DEFAULT_INIT_OPTIONS() {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.i18n.DEFAULT_INIT_OPTIONS;
-  }
-
-  getMergedInitOptions(...initOptions: I18N.InitOptions[]) {
-    return I18N.mergeServiceInitOptions(...initOptions);
-  }
-}
-
-const i18nJsApiLogger = createJsApiLogger(logger, "[I18N JSAPI] =>");
-
-// Standalone init
-export const createI18NJsApi = () =>
-  new I18NJsApi({
-    // LOGGER
-    logger: i18nJsApiLogger,
-    // CHECK
-    serviceChecker: createServiceChecker({ logger: i18nJsApiLogger })
-  });

package/src/jsapi/logger-jsapi.test.ts

@@ -1,45 +0,0 @@
-import { Logger } from "@uuip/unified-ui-platform-sdk";
-import { createLoggerJsApi, LoggerJsApi } from "./logger-jsapi";
-
-describe("Logger JSAPI", () => {
-  let logger: LoggerJsApi;
-
-  beforeEach(() => {
-    logger = createLoggerJsApi();
-  });
-
-  it("creates", () => {
-    expect(logger).toBeDefined();
-    expect(logger["logger"]).toBeDefined();
-  });
-
-  it("createLogger", () => {
-    const clientLogger = logger.createLogger("TEST1");
-
-    expect(clientLogger.prefix).toBe("TEST1");
-  });
-
-  it("get logs", () => {
-    const clientLogger = logger.createLogger("TEST2");
-
-    clientLogger.info("ttt");
-
-    expect(logger.getLogsCollection("TEST2")?.length).toBe(1);
-    expect(logger.getLogsJsonUrl("TEST2")).toContain("data:text/plain;charset=utf-8,");
-    expect(logger.getLogsTextUrl("TEST2")).toContain("data:text/plain;charset=utf-8,");
-  });
-
-  it("browser downloads", () => {
-    const clientLogger = logger.createLogger("TEST3");
-
-    clientLogger.info("bbb");
-
-    const Logger_POOL_browserDownloadPrefixedLogsJson = jest.spyOn(Logger.POOL, "browserDownloadPrefixedLogsJson");
-    logger.browserDownloadLogsJson("TEST3");
-    expect(Logger_POOL_browserDownloadPrefixedLogsJson).toHaveBeenCalledWith("TEST3");
-
-    const Logger_POOL_browserDownloadPrefixedLogsText = jest.spyOn(Logger.POOL, "browserDownloadPrefixedLogsText");
-    logger.browserDownloadLogsText("TEST3");
-    expect(Logger_POOL_browserDownloadPrefixedLogsText).toHaveBeenCalledWith("TEST3");
-  });
-});

package/src/jsapi/logger-jsapi.ts

@@ -1,62 +0,0 @@
-import { createLogger, Logger } from "@uuip/unified-ui-platform-sdk";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-
-type Config = { logger: ReturnType<typeof createJsApiLogger> };
-
-export class LoggerJsApi {
-  private readonly logger: Config["logger"];
-  private readonly clientLoggers: Map<string, Logger.Service> = new Map<string, Logger.Service>();
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-  }
-
-  createLogger(prefix: string) {
-    const clientLogger = createLogger(prefix);
-    this.clientLoggers.set(prefix, clientLogger);
-    this.logger.info(`Client logger created: "${prefix}"`);
-    return clientLogger;
-  }
-
-  cleanupLogs(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      Logger.POOL.cleanupPrefixedLogs(prefix);
-    }
-  }
-
-  browserDownloadLogsJson(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      Logger.POOL.browserDownloadPrefixedLogsJson(prefix);
-    }
-  }
-
-  browserDownloadLogsText(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      Logger.POOL.browserDownloadPrefixedLogsText(prefix);
-    }
-  }
-
-  getLogsCollection(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      return Logger.POOL.getPrefixedLogsCollection(prefix);
-    }
-  }
-
-  getLogsJsonUrl(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      return Logger.POOL.getPrefixedLogsJsonUrl(prefix);
-    }
-  }
-
-  getLogsTextUrl(prefix: string) {
-    if (this.clientLoggers.has(prefix)) {
-      return Logger.POOL.getPrefixedLogsTextUrl(prefix);
-    }
-  }
-}
-
-const loggerJsApiLogger = createJsApiLogger(logger, "[Logger JSAPI] =>");
-
-// Standalone init
-export const createLoggerJsApi = () => new LoggerJsApi({ logger: loggerJsApiLogger });