fcr-core 3.4.0

package/lib/service/type.d.ts

@@ -0,0 +1,7 @@
+export type FcrChatRoomTokenResData = {
+    token: string;
+    appKey: string;
+    orgName: string;
+    appName: string;
+    chatRoomId: string;
+};

package/lib/service/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/type.d.ts

@@ -0,0 +1,254 @@
+import { AgoraRtcNetworkStats, AgoraRteNetworkQualityEvent, AgoraRtcDeviceInfo, AgoraRtcDisplayInfo, AgoraRtcWindowInfo, AgoraRtePerformanceInfo, AgoraRteScenePropertiesDeletedEvent, AgoraRteStreamEncryptionConfig, AgoraRteStreamJoinConfig, AgoraRteDualVideoStreamConfig, AgoraRteMessage, AgoraRteConnectionState, AgoraRteScenePropertiesUpdatedEvent, AgoraRteOperatCause, AgoraRteRenderView, AgoraRteVideoEncoderConfig, AgoraRteLatencyLevel } from './imports';
+import { FcrSharePermissionState } from './room-control/whiteboard-control/enums';
+import { FcrUserLeftReason } from './room-control/user-control/type';
+import { FcrAudioSourceType, FcrMediaSourceState, FcrRegion, FcrRoomConnectorType, FcrStreamType, FcrVideoRenderMode, FcrVideoSourceType } from '.';
+import { FcrRoomJoinOptions, FcrRoomType } from './room-control/type';
+export type FcrCoreEngineConfig = {
+    appId: string;
+    token: string;
+    userId: string;
+    region: FcrRegion;
+    dualCameraVideoStreamConfig: FcrDualVideoStreamConfig;
+    dualScreenVideoStreamConfig: FcrDualVideoStreamConfig;
+    parameters?: Record<string, string | number | object>;
+};
+export type FcrStreamLatencyLevel = AgoraRteLatencyLevel;
+export type FcrDualVideoStreamConfig = AgoraRteDualVideoStreamConfig;
+export declare enum FcrRoomState {
+    Initialized = 0,
+    Started = 1,
+    Ended = 2,
+    Closed = 3
+}
+export declare enum FcrRecordingState {
+    Starting = 1,
+    Started = 2,
+    Paused = 3,
+    Stopped = 4
+}
+export type FcrRoomInfo = {
+    readonly roomId: string;
+    readonly roomName: string;
+    readonly roomType: FcrRoomType;
+    readonly password?: string;
+    readonly inviteLink?: string;
+};
+export type FcrUserInfo = {
+    readonly userId: string;
+    readonly userName: string;
+    readonly userRole: FcrUserRole;
+    readonly connectorType: FcrRoomConnectorType;
+};
+export type FcrStreamInfo = {
+    readonly streamId: string;
+    readonly streamName?: string;
+    readonly owner: FcrUserInfo;
+    readonly streamType: FcrStreamType;
+    readonly videoSourceType: FcrVideoSourceType;
+    readonly audioSourceType: FcrAudioSourceType;
+    readonly videoSourceState: FcrMediaSourceState;
+    readonly audioSourceState: FcrMediaSourceState;
+    readonly videoSourceId?: string;
+    readonly audioSourceId?: string;
+    readonly connectorType: FcrRoomConnectorType;
+};
+export type FcrRoomSchedule = {
+    /**
+     * The start time of the schedule, in milliseconds.
+     */
+    readonly duration: number;
+    /**
+     * The start time of the schedule, in milliseconds.
+     */
+    readonly startTime: number;
+};
+export type FcrRecordInfo = {
+    /**
+     * The state of cloud recording.
+     */
+    readonly state: FcrRecordingState;
+};
+export type FcrMessage = AgoraRteMessage;
+type FcrConnectionState = AgoraRteConnectionState;
+export type FcrCoreEngineObserver = {
+    onConnectionStateUpdated?(state: FcrConnectionState): void;
+    onPeerMessageReceived?(message: FcrMessage): void;
+};
+export type FcrSessionBase = {
+    sessionId: string;
+    sessionKey: string;
+    timestamp: number;
+    duration: number;
+    payload: Record<string, unknown>;
+    senderId: string;
+    interval: number;
+};
+export type FcrSessionResponse = {
+    sessionId: string;
+    sessionKey: string;
+    responderId: string;
+    payload: Record<string, unknown>;
+    cause: Record<string, unknown>;
+};
+export type FcrStreamEncryptionConfig = AgoraRteStreamEncryptionConfig;
+export declare enum FcrDeviceType {
+    Camera = "camera",
+    Microphone = "microphone",
+    Speaker = "speaker"
+}
+export type FcrVideoEncoderConfig = AgoraRteVideoEncoderConfig;
+export type FcrDeviceInfo = AgoraRtcDeviceInfo;
+export type FcrWindowInfo = AgoraRtcWindowInfo;
+export type FcrDisplayInfo = AgoraRtcDisplayInfo;
+export type FcrPerformanceInfo = AgoraRtePerformanceInfo;
+export type FcrStreamJoinConfig = AgoraRteStreamJoinConfig;
+export type FcrRoomPropertiesUpdatedEvent = AgoraRteScenePropertiesUpdatedEvent;
+export type FcrRoomPropertiesDeletedEvent = AgoraRteScenePropertiesDeletedEvent;
+export type FcrNetworkQualityEvent = AgoraRteNetworkQualityEvent;
+export type FcrNetworkStats = AgoraRtcNetworkStats;
+export type FcrGroupInfoFromSceneProperties = {
+    [groupId: string]: {
+        groupName: string;
+        users: {
+            userUuid: string;
+        }[];
+        sort: number;
+    };
+};
+export type FcrRoomJoinSnapshotOptions = {
+    snapshot: unknown;
+    timestamp: number;
+} & Partial<FcrRoomJoinOptions>;
+export type FcrRoomJoinOptionsWithTicket = {
+    ticket?: string;
+} & FcrRoomJoinOptions;
+export type FcrGroupInfo = {
+    groupId: string;
+    groupName: string;
+};
+export type FcrGroupCreateConfig = {
+    groupName: string;
+    userList: string[];
+};
+export type FcrGroupUpdateOptions = {
+    groupId: string;
+    groupName: string;
+};
+export type FcrGroupAddedEvent = {
+    info: FcrGroupInfo;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupUpdatedEvent = {
+    info: FcrGroupInfo;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupRemovedEvent = {
+    info: FcrGroupInfo;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupUserAddedEvent = {
+    groupId: string;
+    userId: string;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupUserMovedEvent = {
+    fromGroupId: string;
+    toGroupId: string;
+    userId: string;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupUserRemovedEvent = {
+    groupId: string;
+    userId: string;
+    reason: FcrUserLeftReason;
+    operatorUser?: FcrUserInfo;
+};
+export type FcrGroupObserver = {
+    onGroupsAdded(events: FcrGroupAddedEvent[]): void;
+    onGroupsUpdated(events: FcrGroupUpdatedEvent[]): void;
+    onGroupsRemoved(events: FcrGroupRemovedEvent[]): void;
+    onUserListAddedToGroup(events: FcrGroupUserAddedEvent[]): void;
+    onUserListMoveToGroup(events: FcrGroupUserMovedEvent[]): void;
+    onUserListRemovedFromGroup(events: FcrGroupUserRemovedEvent[]): void;
+};
+export declare enum FcrSessionState {
+    Starting = 1,
+    Stopped = 2
+}
+export declare enum FcrStreamState {
+    UNPUBLISH = 0,
+    PUBLISH = 1
+}
+export type FcrOperateCause = AgoraRteOperatCause;
+export declare enum FcrCloudRecordingAudioProfile {
+    DEFAULT = 0,// mono 48khz 48kbps
+    MONO_48KHZ_128KBPS = 1,// mono 48khz 128kbps
+    STEREO_48KHZ_192KBPS = 2
+}
+export type FcrCloudRecordingConfig = {
+    videoEncoderConfig: FcrVideoEncoderConfig;
+    audioProfile: FcrCloudRecordingAudioProfile;
+    retryTimeout: number;
+};
+export declare enum FcrUserRole {
+    HOST = 1,
+    COHOST = 2,
+    PARTICIPANT = 3,
+    AUDIENCE = 4,
+    OBSERVER = 5,
+    ROBOT = 6
+}
+export declare const FcrUserRoleToStringMap: {
+    readonly 1: "host";
+    readonly 2: "cohost";
+    readonly 3: "participant";
+    readonly 4: "audience";
+    readonly 5: "observer";
+    readonly 6: "robot";
+};
+export declare const FcrUserStringToRoleMap: {
+    host: FcrUserRole;
+    cohost: FcrUserRole;
+    participant: FcrUserRole;
+    audience: FcrUserRole;
+    observer: FcrUserRole;
+    robot: FcrUserRole;
+};
+export declare enum FcrLiveStreamingLayoutType {
+    GALLERY = 1,
+    SPEAKER = 2
+}
+export interface FcrLiveStreamingConfig {
+    pushStreamingUrl: string;
+    pushStreamingKey: string;
+    pullStreamingUrl: string;
+    layoutType: FcrLiveStreamingLayoutType;
+}
+export declare enum FcrLiveStreamingState {
+    STARTING = 1,
+    STARTED = 2,
+    STOPPED = 3
+}
+export type FcrSharePermissionProps = {
+    screen?: FcrSharePermissionState;
+    board?: {
+        start?: FcrSharePermissionState;
+        write?: FcrSharePermissionState;
+    };
+};
+export type FcrVideoRenderConfig = {
+    renderMode: FcrVideoRenderMode;
+    isMirror: boolean;
+};
+export declare enum FcrLineType {
+    SINGLE_ROW = 1,
+    MULTI_ROW = 2
+}
+export type FcrAllowWatermarkPayloadBody = {
+    lineType: FcrLineType;
+};
+export declare enum RoomMessageKey {
+    USER_WAITING_ROOM_JOINED = "USER_WAITING_ROOM_JOINED"
+}
+export type FcrRenderView = AgoraRteRenderView;
+export {};

package/lib/type.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RoomMessageKey = exports.FcrUserStringToRoleMap = exports.FcrUserRoleToStringMap = exports.FcrUserRole = exports.FcrStreamState = exports.FcrSessionState = exports.FcrRoomState = exports.FcrRecordingState = exports.FcrLiveStreamingState = exports.FcrLiveStreamingLayoutType = exports.FcrLineType = exports.FcrDeviceType = exports.FcrCloudRecordingAudioProfile = void 0;
+let FcrRoomState = exports.FcrRoomState = /*#__PURE__*/function (FcrRoomState) {
+  FcrRoomState[FcrRoomState["Initialized"] = 0] = "Initialized";
+  FcrRoomState[FcrRoomState["Started"] = 1] = "Started";
+  FcrRoomState[FcrRoomState["Ended"] = 2] = "Ended";
+  FcrRoomState[FcrRoomState["Closed"] = 3] = "Closed";
+  return FcrRoomState;
+}({});
+let FcrRecordingState = exports.FcrRecordingState = /*#__PURE__*/function (FcrRecordingState) {
+  FcrRecordingState[FcrRecordingState["Starting"] = 1] = "Starting";
+  FcrRecordingState[FcrRecordingState["Started"] = 2] = "Started";
+  FcrRecordingState[FcrRecordingState["Paused"] = 3] = "Paused";
+  FcrRecordingState[FcrRecordingState["Stopped"] = 4] = "Stopped";
+  return FcrRecordingState;
+}({});
+let FcrDeviceType = exports.FcrDeviceType = /*#__PURE__*/function (FcrDeviceType) {
+  FcrDeviceType["Camera"] = "camera";
+  FcrDeviceType["Microphone"] = "microphone";
+  FcrDeviceType["Speaker"] = "speaker";
+  return FcrDeviceType;
+}({}); // groups
+let FcrSessionState = exports.FcrSessionState = /*#__PURE__*/function (FcrSessionState) {
+  FcrSessionState[FcrSessionState["Starting"] = 1] = "Starting";
+  FcrSessionState[FcrSessionState["Stopped"] = 2] = "Stopped";
+  return FcrSessionState;
+}({});
+let FcrStreamState = exports.FcrStreamState = /*#__PURE__*/function (FcrStreamState) {
+  FcrStreamState[FcrStreamState["UNPUBLISH"] = 0] = "UNPUBLISH";
+  FcrStreamState[FcrStreamState["PUBLISH"] = 1] = "PUBLISH";
+  return FcrStreamState;
+}({});
+let FcrCloudRecordingAudioProfile = exports.FcrCloudRecordingAudioProfile = /*#__PURE__*/function (FcrCloudRecordingAudioProfile) {
+  FcrCloudRecordingAudioProfile[FcrCloudRecordingAudioProfile["DEFAULT"] = 0] = "DEFAULT";
+  FcrCloudRecordingAudioProfile[FcrCloudRecordingAudioProfile["MONO_48KHZ_128KBPS"] = 1] = "MONO_48KHZ_128KBPS";
+  FcrCloudRecordingAudioProfile[FcrCloudRecordingAudioProfile["STEREO_48KHZ_192KBPS"] = 2] = "STEREO_48KHZ_192KBPS";
+  return FcrCloudRecordingAudioProfile;
+}({}); // stereo 48khz 192kbps
+let FcrUserRole = exports.FcrUserRole = /*#__PURE__*/function (FcrUserRole) {
+  FcrUserRole[FcrUserRole["HOST"] = 1] = "HOST";
+  FcrUserRole[FcrUserRole["COHOST"] = 2] = "COHOST";
+  FcrUserRole[FcrUserRole["PARTICIPANT"] = 3] = "PARTICIPANT";
+  FcrUserRole[FcrUserRole["AUDIENCE"] = 4] = "AUDIENCE";
+  FcrUserRole[FcrUserRole["OBSERVER"] = 5] = "OBSERVER";
+  FcrUserRole[FcrUserRole["ROBOT"] = 6] = "ROBOT";
+  return FcrUserRole;
+}({});
+const FcrUserRoleToStringMap = exports.FcrUserRoleToStringMap = {
+  [FcrUserRole.HOST]: 'host',
+  [FcrUserRole.COHOST]: 'cohost',
+  [FcrUserRole.PARTICIPANT]: 'participant',
+  [FcrUserRole.AUDIENCE]: 'audience',
+  [FcrUserRole.OBSERVER]: 'observer',
+  [FcrUserRole.ROBOT]: 'robot'
+};
+const FcrUserStringToRoleMap = exports.FcrUserStringToRoleMap = {
+  host: FcrUserRole.HOST,
+  cohost: FcrUserRole.COHOST,
+  participant: FcrUserRole.PARTICIPANT,
+  audience: FcrUserRole.AUDIENCE,
+  observer: FcrUserRole.OBSERVER,
+  robot: FcrUserRole.ROBOT
+};
+let FcrLiveStreamingLayoutType = exports.FcrLiveStreamingLayoutType = /*#__PURE__*/function (FcrLiveStreamingLayoutType) {
+  FcrLiveStreamingLayoutType[FcrLiveStreamingLayoutType["GALLERY"] = 1] = "GALLERY";
+  FcrLiveStreamingLayoutType[FcrLiveStreamingLayoutType["SPEAKER"] = 2] = "SPEAKER";
+  return FcrLiveStreamingLayoutType;
+}({});
+let FcrLiveStreamingState = exports.FcrLiveStreamingState = /*#__PURE__*/function (FcrLiveStreamingState) {
+  FcrLiveStreamingState[FcrLiveStreamingState["STARTING"] = 1] = "STARTING";
+  FcrLiveStreamingState[FcrLiveStreamingState["STARTED"] = 2] = "STARTED";
+  FcrLiveStreamingState[FcrLiveStreamingState["STOPPED"] = 3] = "STOPPED";
+  return FcrLiveStreamingState;
+}({});
+let FcrLineType = exports.FcrLineType = /*#__PURE__*/function (FcrLineType) {
+  FcrLineType[FcrLineType["SINGLE_ROW"] = 1] = "SINGLE_ROW";
+  FcrLineType[FcrLineType["MULTI_ROW"] = 2] = "MULTI_ROW";
+  return FcrLineType;
+}({});
+let RoomMessageKey = exports.RoomMessageKey = /*#__PURE__*/function (RoomMessageKey) {
+  RoomMessageKey["USER_WAITING_ROOM_JOINED"] = "USER_WAITING_ROOM_JOINED";
+  return RoomMessageKey;
+}({});

package/lib/utilities/cmd.d.ts

@@ -0,0 +1 @@
+export declare const CMD_PEER_MESSAGE = 101;

package/lib/utilities/cmd.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CMD_PEER_MESSAGE = void 0;
+const CMD_PEER_MESSAGE = exports.CMD_PEER_MESSAGE = 101;

package/lib/utilities/collection.d.ts

@@ -0,0 +1,22 @@
+export declare const iterateMap: <K, V, T, E>(map: Map<K, V>, processors?: {
+    onFilter?: (key: K, item: V) => boolean;
+    onMap?: (key: K, item: V) => T;
+    onReduce?: (prev: E, key: K, item: V) => E;
+}) => {
+    list: T[];
+    prev: E;
+};
+export declare const iterateSet: <V, T, E>(map: Set<V>, processors?: {
+    onFilter?: (item: V) => boolean;
+    onMap?: (item: V) => T;
+    onReduce?: (prev: E, item: V) => E;
+}) => {
+    list: T[];
+    prev: E;
+};
+/**
+ * expand a key-value map to a structure
+ * .e.g. { 'a.b.c': 1 } => { a: { b: { c: 1 } } }
+ * @param kvMap
+ */
+export declare const convertToStructure: (kvMap: Record<string, unknown>) => Record<string, unknown>;

package/lib/utilities/collection.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.iterateSet = exports.iterateMap = exports.convertToStructure = void 0;
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+const iterateMap = (map, processors) => {
+  const onFilter = (processors === null || processors === void 0 ? void 0 : processors.onFilter) || (() => true);
+  const {
+    onMap,
+    onReduce
+  } = processors || {};
+  const list = [];
+  let prev = undefined;
+  for (const [k, v] of map.entries()) {
+    if (onFilter(k, v)) {
+      if (onMap) list.push(onMap(k, v));
+      if (onReduce) prev = onReduce(prev, k, v);
+    }
+  }
+  return {
+    list,
+    prev
+  };
+};
+exports.iterateMap = iterateMap;
+const iterateSet = (map, processors) => {
+  const onFilter = (processors === null || processors === void 0 ? void 0 : processors.onFilter) || (() => true);
+  const {
+    onMap,
+    onReduce
+  } = processors || {};
+  const list = [];
+  let prev = undefined;
+  for (const item of map.values()) {
+    if (onFilter(item)) {
+      if (onMap) list.push(onMap(item));
+      if (onReduce) prev = onReduce(prev, item);
+    }
+  }
+  return {
+    list,
+    prev
+  };
+};
+
+/**
+ * expand a key-value map to a structure
+ * .e.g. { 'a.b.c': 1 } => { a: { b: { c: 1 } } }
+ * @param kvMap
+ */
+exports.iterateSet = iterateSet;
+const convertToStructure = kvMap => {
+  const result = {};
+  for (const key in kvMap) {
+    const keys = key.split('.');
+    let temp = result;
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      if (i === keys.length - 1) {
+        temp[k] = kvMap[key];
+      } else {
+        if (!temp[k]) {
+          temp[k] = {};
+        }
+        temp = temp[k];
+      }
+    }
+  }
+  return result;
+};
+exports.convertToStructure = convertToStructure;

package/lib/utilities/error.d.ts

@@ -0,0 +1,41 @@
+export declare class FcrError extends Error {
+    private _code;
+    private _message;
+    private _origin?;
+    get origin(): Error | undefined;
+    get code(): string;
+    get message(): string;
+    constructor(_code: string, _message: string, _origin?: Error | undefined);
+}
+export declare enum FcrErrorCodeType {
+    CLIENT = 6,
+    SERVER = 7
+}
+export declare enum FcrErrorModuleCode {
+    ENGINE = 10,
+    ENGINE_PEER_SESSION = 11,
+    ROOM = 20,
+    ROOM_USER = 21,
+    ROOM_STREAM = 22,
+    ROOM_GROUP = 23,
+    ROOM_CHATROOM = 24,
+    ROOM_SESSION = 25,
+    ROOM_PRIVILEGE = 26,
+    MEDIA_CONTROL = 30,
+    MEDIA_CONTROL_CAMERA = 31,
+    MEDIA_CONTROL_MICROPHONE = 32,
+    MEDIA_CONTROL_LOOPBACK = 33,
+    MEDIA_CONTROL_SCREEN = 34,
+    MONITOR = 40,
+    ROOM_LIVE_STREAMING = 41
+}
+export declare enum FcrErrorCode {
+    UNDEFINED_ERROR = 1,
+    JSON_PARSE_ERROR = 11,
+    LOCAL_HTTP_REQUEST_FAILED = 12,
+    NOT_LOGGED_IN = 13,
+    NOT_JOINED_ROOM = 14,
+    EXPIRED = 15
+}
+export declare const generateFcrCoreClientError: (module: FcrErrorModuleCode, code: number, message: string, origin: Error) => FcrError;
+export declare const generateFcrCoreServerError: (code: number, message: string, origin: Error) => FcrError;

package/lib/utilities/error.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateFcrCoreServerError = exports.generateFcrCoreClientError = exports.FcrErrorModuleCode = exports.FcrErrorCodeType = exports.FcrErrorCode = exports.FcrError = void 0;
+require("core-js/modules/es.error.cause.js");
+var _imports = require("../imports");
+class FcrError extends Error {
+  get origin() {
+    return this._origin;
+  }
+  get code() {
+    return this._code;
+  }
+  get message() {
+    return this._message;
+  }
+  constructor(_code, _message, _origin) {
+    super();
+    this._code = _code;
+    this._message = _message;
+    this._origin = _origin;
+    this.name = 'FcrCoreError';
+  }
+}
+exports.FcrError = FcrError;
+let FcrErrorCodeType = exports.FcrErrorCodeType = /*#__PURE__*/function (FcrErrorCodeType) {
+  FcrErrorCodeType[FcrErrorCodeType["CLIENT"] = 6] = "CLIENT";
+  FcrErrorCodeType[FcrErrorCodeType["SERVER"] = 7] = "SERVER";
+  return FcrErrorCodeType;
+}({});
+let FcrErrorModuleCode = exports.FcrErrorModuleCode = /*#__PURE__*/function (FcrErrorModuleCode) {
+  FcrErrorModuleCode[FcrErrorModuleCode["ENGINE"] = 10] = "ENGINE";
+  FcrErrorModuleCode[FcrErrorModuleCode["ENGINE_PEER_SESSION"] = 11] = "ENGINE_PEER_SESSION";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM"] = 20] = "ROOM";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_USER"] = 21] = "ROOM_USER";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_STREAM"] = 22] = "ROOM_STREAM";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_GROUP"] = 23] = "ROOM_GROUP";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_CHATROOM"] = 24] = "ROOM_CHATROOM";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_SESSION"] = 25] = "ROOM_SESSION";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_PRIVILEGE"] = 26] = "ROOM_PRIVILEGE";
+  FcrErrorModuleCode[FcrErrorModuleCode["MEDIA_CONTROL"] = 30] = "MEDIA_CONTROL";
+  FcrErrorModuleCode[FcrErrorModuleCode["MEDIA_CONTROL_CAMERA"] = 31] = "MEDIA_CONTROL_CAMERA";
+  FcrErrorModuleCode[FcrErrorModuleCode["MEDIA_CONTROL_MICROPHONE"] = 32] = "MEDIA_CONTROL_MICROPHONE";
+  FcrErrorModuleCode[FcrErrorModuleCode["MEDIA_CONTROL_LOOPBACK"] = 33] = "MEDIA_CONTROL_LOOPBACK";
+  FcrErrorModuleCode[FcrErrorModuleCode["MEDIA_CONTROL_SCREEN"] = 34] = "MEDIA_CONTROL_SCREEN";
+  FcrErrorModuleCode[FcrErrorModuleCode["MONITOR"] = 40] = "MONITOR";
+  FcrErrorModuleCode[FcrErrorModuleCode["ROOM_LIVE_STREAMING"] = 41] = "ROOM_LIVE_STREAMING";
+  return FcrErrorModuleCode;
+}({});
+let FcrErrorCode = exports.FcrErrorCode = /*#__PURE__*/function (FcrErrorCode) {
+  FcrErrorCode[FcrErrorCode["UNDEFINED_ERROR"] = 1] = "UNDEFINED_ERROR";
+  FcrErrorCode[FcrErrorCode["JSON_PARSE_ERROR"] = 11] = "JSON_PARSE_ERROR";
+  FcrErrorCode[FcrErrorCode["LOCAL_HTTP_REQUEST_FAILED"] = 12] = "LOCAL_HTTP_REQUEST_FAILED";
+  FcrErrorCode[FcrErrorCode["NOT_LOGGED_IN"] = 13] = "NOT_LOGGED_IN";
+  FcrErrorCode[FcrErrorCode["NOT_JOINED_ROOM"] = 14] = "NOT_JOINED_ROOM";
+  FcrErrorCode[FcrErrorCode["EXPIRED"] = 15] = "EXPIRED";
+  return FcrErrorCode;
+}({}); // helpers
+const generateFcrCoreClientError = (module, code, message, origin) => {
+  return new FcrError("".concat((0, _imports.padEnd)(String(FcrErrorCodeType.CLIENT), 3, '0')).concat((0, _imports.padStart)(String(module), 3, '0')).concat((0, _imports.padStart)(String(code), 3, '0')), "domain: CORE-CLIENT, info: ".concat(message), origin);
+};
+exports.generateFcrCoreClientError = generateFcrCoreClientError;
+const generateFcrCoreServerError = (code, message, origin) => {
+  return new FcrError("".concat(FcrErrorCodeType.SERVER).concat((0, _imports.padStart)(String(code), 3, '0')), "domain: CORE-SRV, info: ".concat(message), origin);
+};
+exports.generateFcrCoreServerError = generateFcrCoreServerError;

package/lib/utilities/package-info.d.ts

@@ -0,0 +1 @@
+export declare const getVersion: () => string;

package/lib/utilities/package-info.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVersion = void 0;
+var _package = _interopRequireDefault(require("../../package.json"));
+const getVersion = () => {
+  return _package.default.version;
+};
+exports.getVersion = getVersion;

package/lib/utilities/parameters.d.ts

@@ -0,0 +1,9 @@
+export declare const isTrueValue: (value: unknown) => boolean;
+type FcrCoreEngineParameters = {
+    core?: Record<string, unknown>;
+};
+export declare const getCoreIpList: (parameters?: FcrCoreEngineParameters) => string[];
+export declare const getEasemobChatIpList: (parameters?: FcrCoreEngineParameters) => string[];
+export declare const getEasemobRestIpList: (parameters?: FcrCoreEngineParameters) => string[];
+export declare const isEndpointRegionDisabled: (parameters?: FcrCoreEngineParameters) => boolean;
+export {};

package/lib/utilities/parameters.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTrueValue = exports.isEndpointRegionDisabled = exports.getEasemobRestIpList = exports.getEasemobChatIpList = exports.getCoreIpList = void 0;
+const isTrueValue = value => {
+  return value === 'true' || !!value;
+};
+exports.isTrueValue = isTrueValue;
+const getCoreIpList = parameters => {
+  var _parameters$core;
+  return parameters === null || parameters === void 0 || (_parameters$core = parameters.core) === null || _parameters$core === void 0 ? void 0 : _parameters$core.coreIpList;
+};
+exports.getCoreIpList = getCoreIpList;
+const getEasemobChatIpList = parameters => {
+  var _parameters$core2;
+  return parameters === null || parameters === void 0 || (_parameters$core2 = parameters.core) === null || _parameters$core2 === void 0 ? void 0 : _parameters$core2.easemobChatIpList;
+};
+exports.getEasemobChatIpList = getEasemobChatIpList;
+const getEasemobRestIpList = parameters => {
+  var _parameters$core3;
+  return parameters === null || parameters === void 0 || (_parameters$core3 = parameters.core) === null || _parameters$core3 === void 0 ? void 0 : _parameters$core3.easemobRestIpList;
+};
+exports.getEasemobRestIpList = getEasemobRestIpList;
+const isEndpointRegionDisabled = parameters => {
+  var _parameters$core4;
+  return isTrueValue(parameters === null || parameters === void 0 || (_parameters$core4 = parameters.core) === null || _parameters$core4 === void 0 ? void 0 : _parameters$core4.disableEndpointRegion);
+};
+exports.isEndpointRegionDisabled = isEndpointRegionDisabled;

package/lib/utilities/stream.d.ts

@@ -0,0 +1,27 @@
+import { FcrStreamJoinConfig } from "../type";
+export declare const getStreamJoinConfig: (stream?: FcrStreamJoinConfig) => {
+    videoSourceUuid: string | undefined;
+    audioSourceUuid: string | undefined;
+    videoEncoderConfig?: import("agora-rte-sdk/lib/core/rtc/type").AgoraRtcVideoEncoderConfiguration;
+    videoSourceId?: string;
+    audioSourceId?: string;
+    streamName?: string;
+    streamType?: import("agora-rte-sdk/lib/core/scene/type").AgoraRteMediaStreamType | undefined;
+    videoSourceType?: import("agora-rte-sdk/lib/type").AgoraRteVideoSourceType | undefined;
+    audioSourceType?: import("agora-rte-sdk/lib/type").AgoraRteAudioSourceType | undefined;
+    audioSourceState?: import("agora-rte-sdk/lib/type").AgoraRteMediaSourceState;
+    videoSourceState?: import("agora-rte-sdk/lib/type").AgoraRteMediaSourceState;
+};
+export declare const getStreamsJoinConfig: (streams?: FcrStreamJoinConfig[]) => {
+    videoSourceUuid: string | undefined;
+    audioSourceUuid: string | undefined;
+    videoEncoderConfig?: import("agora-rte-sdk/lib/core/rtc/type").AgoraRtcVideoEncoderConfiguration;
+    videoSourceId?: string;
+    audioSourceId?: string;
+    streamName?: string;
+    streamType: import("agora-rte-sdk/lib/core/scene/type").AgoraRteMediaStreamType;
+    videoSourceType: import("agora-rte-sdk/lib/type").AgoraRteVideoSourceType;
+    audioSourceType: import("agora-rte-sdk/lib/type").AgoraRteAudioSourceType;
+    audioSourceState?: import("agora-rte-sdk/lib/type").AgoraRteMediaSourceState;
+    videoSourceState?: import("agora-rte-sdk/lib/type").AgoraRteMediaSourceState;
+}[] | undefined;