@wxcc-desktop/sdk 1.2.6 → 1.2.10

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

@@ -1,80 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createScreenPopJsApi } from "./screenpop-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: ({
-        screenpop: {
-          eScreenPop: { listen: jest.fn(), listenOnce: jest.fn() }
-        }
-      } as unknown) as AgentxServices["aqm"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("ScreenPop JSAPI", () => {
-  let screenPop: ReturnType<typeof createScreenPopJsApi>;
-
-  beforeEach(() => {
-    (SERVICE as AgentxServices).init("fake-token");
-
-    screenPop = createScreenPopJsApi();
-
-    screenPop.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(screenPop).toBeDefined();
-    expect(screenPop["logger"]).toBeDefined();
-    expect(screenPop["serviceChecker"]).toBeDefined();
-    expect(screenPop["aqmEvents"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(screenPop["checkService"]()).toBeTruthy();
-    expect(screenPop["aqmEvents"].isInited).toBeTruthy();
-  });
-
-  it("checks service", () => {
-    screenPop["serviceChecker"].check = jest.fn();
-    screenPop["checkService"]();
-
-    expect(screenPop["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("listens", () => {
-    const listener = () => {};
-    screenPop.addEventListener("eScreenPop", listener);
-    expect(screenPop["aqmEvents"]["listeners"].size).toBe(1);
-    expect(SERVICE.aqm.screenpop.eScreenPop.listen).toHaveBeenCalledWith(listener);
-    screenPop.removeEventListener("eScreenPop", listener);
-    expect(screenPop["aqmEvents"]["listeners"].size).toBe(0);
-  });
-
-  it("listensOnce", () => {
-    const listener = () => {};
-    screenPop.addOnceEventListener("eScreenPop", listener);
-    expect(screenPop["aqmEvents"]["listenersOnce"].size).toBe(1);
-    expect(SERVICE.aqm.screenpop.eScreenPop.listenOnce).toHaveBeenCalledWith(listener);
-    screenPop.removeOnceEventListener("eScreenPop", listener);
-    expect(screenPop["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-
-  it("removesAllListeners", () => {
-    const listener1 = () => {};
-    const listener2 = () => {};
-    screenPop.addEventListener("eScreenPop", listener1);
-    screenPop.addOnceEventListener("eScreenPop", listener2);
-    expect(screenPop["aqmEvents"]["listeners"].size).toBe(1);
-    expect(screenPop["aqmEvents"]["listenersOnce"].size).toBe(1);
-    screenPop.removeAllEventListeners();
-    expect(screenPop["aqmEvents"]["listeners"].size).toBe(0);
-    expect(screenPop["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-});

package/src/jsapi/screenpop-jsapi.ts

@@ -1,100 +0,0 @@
-import { AgentxService } 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 = {
-  eScreenPop: Parameters<AgentxService["aqm"]["screenpop"]["eScreenPop"]["listen"]>[0];
-};
-
-type Config = {
-  logger: ReturnType<typeof createJsApiLogger>;
-  aqmEvents: AqmServiceEntityEvents<Listeners>;
-  serviceChecker: ReturnType<typeof createServiceChecker>;
-};
-
-export class ScreenPopJsApi {
-  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.screenpop,
-      aqmServiceEntityString: "SERVICE.aqm.screenpop"
-    });
-
-    this.logger.info("Inited");
-  }
-
-  cleanup() {
-    this.aqmEvents.cleanup();
-
-    this.SERVICE = undefined;
-
-    this.logger.info("Cleaned");
-  }
-
-  // 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 screenPopJsApiLogger = createJsApiLogger(logger, "[ScreenPop JSAPI] =>");
-const aqmServiceScreenPopJsApiLogger = createJsApiLogger(screenPopJsApiLogger, "[AqmServiceEvents: ScreenPop] =>");
-
-// Standalone init
-export const createScreenPopJsApi = () =>
-  new ScreenPopJsApi({
-    logger: screenPopJsApiLogger,
-    aqmEvents: createServiceEvents<Listeners>({
-      logger: aqmServiceScreenPopJsApiLogger
-    }),
-    serviceChecker: createServiceChecker({ logger: screenPopJsApiLogger })
-  });

package/src/jsapi/shortcut-key-jsapi.test.ts

@@ -1,88 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createShortcutKeyJsApi } from "./shortcut-key-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      },
-      shortcut: ({
-        event: {
-          listenKeyPress: jest.fn(),
-          listenKeyConflict: jest.fn(),
-          listenConflictResolved: jest.fn()
-        },
-        register: jest.fn(),
-        unregisterKeys: jest.fn(),
-        getRegisteredKeys: jest.fn(),
-        DEFAULT_SHORTCUT_KEYS: { test: "DEFAULT_SHORTCUT_KEYS" },
-        MODIFIERS: { test: "MODIFIERS" },
-        REGISTERED_KEYS: { test: "REGISTERED_KEYS" }
-      } as unknown) as AgentxServices["shortcut"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("ShortcutKey JSAPI", () => {
-  let shortcutKey: ReturnType<typeof createShortcutKeyJsApi>;
-
-  beforeEach(async () => {
-    await (SERVICE as AgentxServices).init("fake-token");
-
-    shortcutKey = createShortcutKeyJsApi();
-    shortcutKey.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(shortcutKey).toBeDefined();
-    expect(shortcutKey["logger"]).toBeDefined();
-    expect(shortcutKey["serviceChecker"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(shortcutKey["checkService"]()).toBeTruthy();
-  });
-
-  it("cleanups", () => {
-    shortcutKey.cleanup();
-    expect(shortcutKey["SERVICE"]).toBeUndefined();
-  });
-
-  it("checks service", () => {
-    shortcutKey["serviceChecker"].check = jest.fn();
-    shortcutKey["checkService"]();
-
-    expect(shortcutKey["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("listens", () => {
-    const listener1 = () => {};
-    shortcutKey.listenKeyPress(listener1);
-    expect(SERVICE.shortcut.event.listenKeyPress).toHaveBeenCalledWith(listener1);
-
-    const listener2 = () => {};
-    shortcutKey.listenKeyConflict(listener2);
-    expect(SERVICE.shortcut.event.listenKeyConflict).toHaveBeenCalledWith(listener2);
-
-    const listener3 = () => {};
-    shortcutKey.listenConflictResolved(listener3);
-    expect(SERVICE.shortcut.event.listenConflictResolved).toHaveBeenCalledWith(listener3);
-  });
-
-  it("registers/unregisters", () => {
-    shortcutKey.register({ test: "A" } as any);
-    expect(SERVICE.shortcut.register).toHaveBeenCalledWith({ test: "A" });
-
-    shortcutKey.unregisterKeys({ test: "B" } as any);
-    expect(SERVICE.shortcut.unregisterKeys).toHaveBeenCalledWith({ test: "B" });
-  });
-
-  it("gets constants", () => {
-    expect(shortcutKey.DEFAULT_SHORTCUT_KEYS).toEqual({ test: "DEFAULT_SHORTCUT_KEYS" });
-    expect(shortcutKey.REGISTERED_KEYS).toEqual({ test: "REGISTERED_KEYS" });
-    expect(shortcutKey.MODIFIERS).toEqual({ test: "MODIFIERS" });
-  });
-});

package/src/jsapi/shortcut-key-jsapi.ts

@@ -1,112 +0,0 @@
-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 ShortcutKeyJsApi {
-  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");
-  }
-
-  // Service-related
-
-  listenKeyPress(...args: Parameters<AgentxService["shortcut"]["event"]["listenKeyPress"]>) {
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.SERVICE?.shortcut.event.listenKeyPress(...args);
-  }
-
-  listenKeyConflict(...args: Parameters<AgentxService["shortcut"]["event"]["listenKeyConflict"]>) {
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.SERVICE?.shortcut.event.listenKeyConflict(...args);
-  }
-
-  listenConflictResolved(...args: Parameters<AgentxService["shortcut"]["event"]["listenConflictResolved"]>) {
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.SERVICE?.shortcut.event.listenConflictResolved(...args);
-  }
-
-  register(...args: Parameters<AgentxService["shortcut"]["register"]>) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.SERVICE?.shortcut.register(...args);
-  }
-
-  unregisterKeys(...args: Parameters<AgentxService["shortcut"]["unregisterKeys"]>) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.SERVICE?.shortcut.unregisterKeys(...args);
-  }
-
-  getRegisteredKeys() {
-    if (!this.checkService()) {
-      return;
-    }
-
-    return this.SERVICE?.shortcut.getRegisteredKeys();
-  }
-
-  get DEFAULT_SHORTCUT_KEYS() {
-    return this.SERVICE?.shortcut.DEFAULT_SHORTCUT_KEYS;
-  }
-
-  get MODIFIERS() {
-    return this.SERVICE?.shortcut.MODIFIERS;
-  }
-
-  get REGISTERED_KEYS() {
-    return this.SERVICE?.shortcut.REGISTERED_KEYS;
-  }
-}
-
-const shortcutKeyJsApiLogger = createJsApiLogger(logger, "[ShortcutKey JSAPI] =>");
-
-export const createShortcutKeyJsApi = () =>
-  new ShortcutKeyJsApi({
-    logger: shortcutKeyJsApiLogger,
-    serviceChecker: createServiceChecker({ logger: shortcutKeyJsApiLogger })
-  });

package/src/sdk.ts

@@ -1,3 +0,0 @@
-import { createLogger } from "@uuip/unified-ui-platform-sdk";
-
-export const logger = createLogger("agentx-js-api");

package/src/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2016",
-    "module": "esnext",
-    "moduleResolution": "node",
-    "types": ["node", "jest"],
-
-    "strict": true,
-    "removeComments": false,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-
-    "declaration": true,
-    "declarationDir": "../dist/types"
-  },
-  "include": ["**/*.ts"]
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2016",
-    "module": "commonjs",
-
-    "strict": true,
-    "esModuleInterop": true
-  },
-  "files": [
-    "webpack.config.ts",
-    "webpack.config.dev.server.ts"
-  ]
-}

package/webpack.config.dev.server.ts

@@ -1,12 +0,0 @@
-import merge from "webpack-merge";
-import { commonDev, pBuild } from "./webpack.config";
-
-export default merge(commonDev, {
-  devServer: {
-    contentBase: pBuild,
-    historyApiFallback: true,
-    open: true,
-    hot: true,
-    port: 3333
-  }
-});

package/webpack.config.ts

@@ -1,134 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { CleanWebpackPlugin } from "clean-webpack-plugin";
-import CopyWebpackPlugin from "copy-webpack-plugin";
-import HtmlWebpackPlugin from "html-webpack-plugin";
-import * as path from "path";
-import RemovePlugin from "remove-files-webpack-plugin";
-import * as webpack from "webpack";
-import merge from "webpack-merge";
-//import nodeExternals from "webpack-node-externals";
-
-const pSrc = path.resolve("src");
-const pDist = path.resolve("dist");
-export const pBuild = path.resolve("build");
-
-const common: webpack.Configuration = {
-  output: {
-    publicPath: "/"
-  },
-  resolve: {
-    extensions: [".ts", ".js"]
-  }
-};
-
-function ruleTS({ isDev }: { isDev: boolean }) {
-  return {
-    test: /\.ts$/,
-    loader: "ts-loader",
-    include: pSrc,
-    options: {
-      compilerOptions: {
-        declarationMap: isDev,
-        sourceMap: isDev
-      }
-    }
-  };
-}
-
-// DEV
-// ----------
-
-export const commonDev = merge(common, {
-  name: "dev",
-  mode: "development",
-  devtool: "source-map",
-  entry: {
-    index: "./src/[sandbox]/sandbox.ts"
-  },
-  output: {
-    path: pBuild
-  },
-  module: {
-    rules: [ruleTS({ isDev: true })]
-  },
-  plugins: [
-    new CopyWebpackPlugin({
-      patterns: [{ from: "./src/[sandbox]/assets/i18n", to: "i18n" }]
-    }),
-    new webpack.ProvidePlugin({
-      AGENTX_SERVICE: ["@wxcc-desktop/sdk-types", "SERVICE"]
-    }),
-    new HtmlWebpackPlugin({
-      template: "./src/[sandbox]/index.html",
-      favicon: "./src/[sandbox]/favicon.ico" //
-    })
-  ]
-});
-
-const dev = merge(commonDev, {
-  plugins: [new CleanWebpackPlugin()]
-});
-
-// DIST
-// ----------
-
-const commonDist = merge(common, {
-  entry: {
-    index: "./src/index.ts"
-  },
-  output: {
-    path: pDist,
-    filename: "[name].js",
-    libraryTarget: "umd"
-  },
-  //externals: [nodeExternals({ modulesFromFile: true })],
-  plugins: [
-    new CleanWebpackPlugin(),
-    new RemovePlugin({
-      after: {
-        log: false,
-        include: ["./dist/types/[sandbox]"],
-        test: [
-          {
-            folder: "./dist/types",
-            method: p => new RegExp(/\.test\.d\.ts(\.map)*$/).test(p),
-            recursive: true
-          }
-        ]
-      }
-    }) as any
-  ]
-});
-
-const distDev = merge(commonDist, {
-  name: "distDev",
-  mode: "development",
-  devtool: "source-map",
-  module: {
-    rules: [ruleTS({ isDev: true })]
-  },
-  // Just for check built widget in AgentX (for example)
-  entry: {
-    ["widget-using-js-api"]: "./src/[sandbox]/widget-using-js-api.ts"
-  },
-  plugins: [
-    new CopyWebpackPlugin({
-      patterns: [{ from: "./src/[sandbox]/assets/i18n/widget-using-js-api", to: "i18n/widget-using-js-api" }]
-    })
-  ]
-});
-
-const distDevWatch = merge(distDev, {
-  name: "distDevWatch",
-  watch: true
-});
-
-const distProd = merge(commonDist, {
-  name: "distProd",
-  mode: "production",
-  module: {
-    rules: [ruleTS({ isDev: false })]
-  }
-});
-
-export default [dev, distDev, distDevWatch, distProd];