@hysc/meeting 10.0.11 → 10.0.12

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@hysc/meeting",
-  "version": "10.0.11",
+  "version": "10.0.12",
   "description": "boom meeting",
   "private": false,
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
@@ -18,16 +18,16 @@
     "@hysc/p-queue": "6.3.0",
     "rxjs": "^7.5.5",
     "typescript": "^4.6.3",
-    "@hysc/bloud": "10.0.11",
-    "@hysc/core": "10.0.11",
-    "@hysc/utils": "10.0.11"
+    "@hysc/bloud": "10.0.12",
+    "@hysc/core": "10.0.12",
+    "@hysc/utils": "10.0.12"
   },
   "peerDependencies": {
-    "@hysc/core": "10.0.11"
+    "@hysc/core": "10.0.12"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.6",
-    "@hysc/brtc": "10.0.11"
+    "@hysc/brtc": "10.0.12"
   },
   "scripts": {
     "build": "tsup ./src/index.ts --format cjs,esm --dts --minify",

package/umd/boom-core/src/BoomCore/BCClient/clientEventType.d.ts

@@ -1,428 +0,0 @@
-export declare enum BCEvent {
-    /**
-     * 房间建立连接成功后的事件
-     * ```javascript
-     * boomCore.on('room-connected', () => {
-     *   console.log('房间建立成功');
-     * });
-     * ```
-     */
-    ROOM_CONNECTED = "room-connected",
-    ROOM_RECONNECTING = "room-reconnecting",
-    /**
-     * 房间信令重连成功后的事件
-     * ```javascript
-     * boomCore.on('room-reconnected', () => {
-     *   console.log('房间重新建立成功');
-     * });
-     * ```
-     */
-    ROOM_RECONNECTED = "room-reconnected",
-    ROOM_SYNC = "room-synced",
-    /**
-     * 用户加入房间成功后的事件
-     * ```javascript
-     * boomCore.on('participant-joined', () => {
-     *   console.log('有用户加入房间');
-     * });
-     * ```
-     */
-    JOINUSER = "participant-joined",
-    /**
-     * 用户离开房间成功后的事件
-     * ```javascript
-     * boomCore.on('participant-left', () => {
-     *   console.log('有用户离开房间');
-     * });
-     * ```
-     */
-    LEAVEUSER = "participant-left",
-    /**
-     * 房间发生错误后的事件
-     * ```javascript
-     * boomCore.on('room-error', () => {
-     *   console.log('房间发生错误');
-     * });
-     * ```
-     */
-    ROOMERROR = "room-error",
-    /**
-     * 用户退出推流事件
-     * ```javascript
-     * @property {Participant} participant - 退出推流用户
-     * @property {String[]} streams - 退出推流ID列表
-     * boomCore.on('participant-unpublished', () => {
-     *   console.log('用户退出推流事');
-     * });
-     * ```
-     */
-    UNPUBLISH = "participant-unpublished",
-    /**
-     * 用户推流事件
-     * ```javascript
-     * @property {Participant} participant - 用户
-     * @property {Stream[]} streams - 主码流列表
-     * @property {Stream[]} subStreams - 子码流列表
-     * boomCore.on('participant-published', () => {
-     *   console.log('用户推流');
-     * });
-     * ```
-     */
-    PUBLISHED = "participant-published",
-    /**
-     * 房间消息发送事件
-     * ```javascript
-     * boomCore.on('new-message', () => {
-     *   console.log('房间消息发送');
-     * });
-     * ```
-     */
-    SENDMESSAGE = "new-message",
-    /**
-     * 房间消息接收事件
-     * ```javascript
-     * boomCore.on('custom-message', () => {
-     *   console.log('房间消息接收');
-     * });
-     * ```
-     */
-    CUSTOMMESSAGE = "custom-message",
-    /**
-     * 用户推流出错事件
-     * ```javascript
-     * boomCore.on('error-media', () => {
-     *   console.log('用户推流出错');
-     * });
-     * ```
-     */
-    STREAMERROR = "error-media",
-    /**
-     * 推流中断事件
-     * ```javascript
-     * boomCore.on('stream-disconnected', () => {
-     *   console.log('推流中断');
-     * });
-     * ```
-     */
-    STREAMDISCONNECTED = "stream-disconnected",
-    /**
-     * 用户被踢出后事件
-     * ```javascript
-     * boomCore.on('participant-evicted', () => {
-     *   console.log('用户被踢出');
-     * });
-     * ```
-     */
-    EVICTED = "participant-evicted",
-    /**
-     * 房间属性更新后的事件
-     * ```javascript
-     * boomCore.on('update-stats', () => {
-     *   console.log('房间信息改变');
-     * });
-     * ```
-     */
-    UPDATESTATS = "update-stats",
-    /**
-     * 房间自定义属性更新后的事件
-     * ```javascript
-     * boomCore.on('update-custom-stats', () => {
-     *   console.log('房间信息改变');
-     * });
-     * ```
-     */
-    CUSTOMSTATS = "update-custom-stats",
-    /**
-     * 用户信息改变后的事件
-     * ```javascript
-     * boomCore.on('participant-update', () => {
-     *   console.log('用户信息改变');
-     * });
-     * ```
-     */
-    UPDATEUSER = "participant-update",
-    /**
-     * 房间管理员改变后的事件
-     * ```javascript
-     * boomCore.on('change-master', () => {
-     *   console.log('房间管理员改变');
-     * });
-     * ```
-     */
-    CHANGEMASTER = "change-master",
-    /**
-     * 用户在其它端登陆后的事件
-     * ```javascript
-     * boomCore.on('user-rejoined', () => {
-     *   console.log('用户在其它端登陆');
-     * });
-     * ```
-     */
-    USERREJOINED = "user-rejoined",
-    /**
-     * token即将过期的事件
-     * ```javascript
-     * boomCore.on('token-will-expire', () => {
-     *   console.log('token即将过期');
-     * });
-     * ```
-     */
-    TOKENWILLEXPIRE = "token-will-expire",
-    /**
-     * token过期的事件
-     * ```javascript
-     * boomCore.on('token-expire', () => {
-     *   console.log('token过期');
-     * });
-     * ```
-     */
-    TOKENEXPIRE = "token-expire",
-    /**
-     * 候选人进入事件
-     * ```javascript
-     * boomCore.on('onIceCandidate', () => {
-  
-     * });
-     * ```
-     */
-    ICECANDIDATE = "onIceCandidate",
-    /**
-     * 流更新事件事件
-     * ```javascript
-     @param stream 流对象
-     * boomCore.on('stream-update', (stream) => {
-  
-     * });
-     * ```
-     */
-    STREAMUPDATE = "stream-update",
-    UPDATE = "update",
-    /**
-     * 流智能分析数据完成后
-     * @property {Stream} stream - 流对象
-     * @property {Object} data - 智能分析数据，除type外依不同算法不同
-     * @property {String} data.type - 智能分析类型，用于区分不同算法
-     * boomCore.on('analysis-data', (params) => {
-  
-     * });
-     * ```
-     */
-    ANALYSISDATA = "analysis-data",
-    /**
-     * 流智能分析数据出错
-     * @property {Stream} stream - 流对象
-     * @property {Object} analyze - 智能分析参数(待确认)
-     * boomCore.on('analysis-error', (params) => {
-  
-     * });
-     * ```
-     */
-    ANALYSISERROR = "analysis-error",
-    /**
-     * 流启动智能分析
-     * @property {Stream} stream - 流对象
-     * @property {Object} analyze   - 智能分析参数
-     * @property {String} analyze.type  - 智能分析类型，用于区分不同算法
-     * @property {Number} analyze.width - 智能分析输入宽度
-     * @property {Number} analyze.height    - 智能分析输入高度
-     * @property {Object} analyze.params    - 智能分析算法参数，算法参数部分置于此处
-     * @property {String} analyze.params.type   - 智能分析算法名
-     * @property {Number} analyze.params.fps    - 智能分析处理帧率
-     * boomCore.on('start-analyze', (params) => {
-  
-     * });
-     * ```
-     */
-    STARTANALYSIS = "start-analyze",
-    /**
-     * 流停止智能分析
-     * @property {Stream} stream - 流对象
-     * @property {Object} analyze   - 智能分析参数
-     * @property {String} analyze.type  - 智能分析类型，用于区分不同算法
-     * boomCore.on('stop-analyze', (params) => {
-  
-     * });
-     * ```
-     */
-    STOPANALYSIS = "stop-analyze",
-    /**
-     * 房间数据上报
-     * @property {Object} info - 上报数据
-     * boomCore.on('stop-analyze', (info) => {
-  
-     * });
-     * ```
-     */
-    REPORTINFO = "info-reported",
-    /**
-     * 远端流添加事件，当远端用户发布流后会收到该通知
-     * ```javascript
-     * client.on('stream-added', event => {
-     *   const remoteStream = event.stream;s
-     * });
-     * ```
-     */
-    STREAM_ADDED = "stream-added",
-    /**
-     * 远端流移除事件，当远端用户取消发布流后会收到该通知。
-     * ```javascript
-     * client.on('stream-removed', event => {
-     *   const remoteStream = event.stream;
-     * });
-     * ```
-     */
-    STREAM_REMOVED = "stream-removed",
-    /**
-     * 远端流更新事件，当远端用户添加、移除或更换音视频轨道后会收到该通知
-     * ```javascript
-     * client.on('stream-updated', event => {
-     *   const remoteStream = event.stream;
-     * });
-     * ```
-     */
-    STREAM_UPDATED = "stream-updated",
-    BLOUD_STREAM_UPDATED = "bloud-stream-update",
-    MOVE_USER_ROOM = "move-user-room",
-    /**
-     * 本地流推流成功事件，调用 publish() 成功后会触发该事件
-     * ```javascript
-     * client.on('stream-published', event => {
-     *   const localStream = event.stream;
-     * });
-     * ```
-     */
-    STREAM_PUBLISHED = "stream-published",
-    /**
-     * 远端流订阅成功事件，调用 subscribe() 成功后会触发该事件
-     * ```javascript
-     * client.on('stream-subscribed', event => {
-     *   const remoteStream = event.stream;
-     * });
-     * ```
-     */
-    STREAM_SUBSCRIBED = "stream-subscribed",
-    /**
-     * 远端用户禁用视频通知
-     * ```javascript
-     * client.on('mute-video', event => {
-     *   const stream = event.stream;
-     * });
-     * ```
-     */
-    MUTE_VIDEO = "mute-video",
-    /**
-     * 远端用户取消禁用视频通知
-     * ```javascript
-     * client.on('unmute-video', event => {
-     *   const stream = event.stream;
-     * });
-     * ```
-     */
-    UNMUTE_VIDEO = "unmute-video",
-    /**
-     * 远端用户禁用音频通知
-     * ```javascript
-     * client.on('mute-audio', event => {
-     *   const stream = event.stream;
-     * });
-     * ```
-     */
-    MUTE_AUDIO = "mute-audio",
-    /**
-     * 远端用户取消禁用音频通知
-     * ```javascript
-     * client.on('mute-audio', event => {
-     *   const stream = event.stream;
-     * });
-     * ```
-     */
-    UNMUTE_AUDIO = "unmute-audio",
-    /**
-     * 客户端错误事件，当出现不可恢复错误后 Client 会通过该事件上报
-     * ```javascript
-     * client.on('error', error => {
-     *   console.error('client error observed: ' + error);
-     *   const errorCode = error.getCode();
-     *   // 当出现客户端错误后，请调用 client.leave() 退房并尝试通过 client.join() 重新进房恢复通话。
-     * });
-     * ```
-     */
-    ERROR = "error",
-    /**
-     * 用户进入房间通知
-     * ```javascript
-     * client.on('peer-joined', event => {
-     *   const userId = event.userId;
-     * });
-     * ```
-     */
-    PEER_JOINED = "peer-joined",
-    /**
-     * 用户退出房间通知
-     * ```javascript
-     * client.on('peer-leaved', event => {
-     *   const userId = event.userId;
-     * });
-     * ```
-     */
-    PEER_LEAVED = "peer-leaved",
-    /**
-     * client 被踢出房间通知，其他端以相同的 user_id 进入了房间
-     * ```javascript
-     * client.on('client-banned', () => {
-     *   console.log('你已被踢出！');
-     * });
-     * ```
-     */
-    CLIENT_BANNED = "client-banned",
-    /**
-     * 用户被踢出房间通知，被管理员踢出
-     * ```javascript
-     * client.on('user-kicked', () => {
-     *   console.log('你已被踢出！');
-     * });
-     * ```
-     */
-    USER_KICKED = "user-kicked",
-    /**
-     * token 即将过期
-     * ```javascript
-     * client.on('token-will-expire', () => {
-     *   console.log('你的 token 即将过期，请更新 token');
-     * });
-     * ```
-     */
-    TOKEN_WILL_EXPIRE = "token-will-expire",
-    /**
-     * token 过期
-     * ```javascript
-     * client.on('token-expire', () => {
-     *   console.log('你的 token 已经过期，已自动退出房间');
-     * });
-     * ```
-     */
-    TOKEN_EXPIRE = "token-expire",
-    /**
-     * 房间关闭
-     * ```javascript
-     * client.on('room-closed', () => {
-     *   console.log('房间已关闭，已自动退出');
-     * });
-     * ```
-     */
-    ROOM_CLOSED = "room-closed",
-    /**
-     * 房间网络异常
-     * bloud -> disconnect -> ee.emit('network-error')
-     */
-    NETWORK_ERROR = "network-error",
-    BRTC_SYNC_ROOM_COMPLETED = "sync-room-completed",
-    BRTC_ROOM_ROCONNECTING = "brtc-room-reconnecting",
-    BRTC_ROOM_RECONNECTED = "brtc-room-reconnected",
-    JOIN_READY = "join-ready",
-    BRTC_SHARE_SYNC_ROOM_COMPLETED = "brtc-share-sync-room-completed",
-    LEAVE_USERS = "leaveUsers",
-    ROOM_ERROR = "error-room",
-    UPDATE_STREAM = "update-stream"
-}
-export default BCEvent;

package/umd/boom-meeting/src/BMChat/BMChatVM.d.ts

@@ -1,26 +0,0 @@
-import BoomCore from '@hysc/core/esm';
-import BMMessageInfo from './BMMessageInfo';
-import { BehaviorSubject, Subject } from "rxjs";
-import BMUserVM from '../BMUser/BMUserVM';
-import BMRoom from '../BMRoom/BMRoom';
-export default class BMChatVM {
-    messageList: Array<BMMessageInfo>;
-    boomCore: BoomCore;
-    userVM: BMUserVM;
-    bmRoom: BMRoom;
-    messageListWatcher: BehaviorSubject<Array<BMMessageInfo>>;
-    hasDangerMessageWatcher: Subject<boolean>;
-    constructor(boomCore: BoomCore, userVM: BMUserVM, bmRoom: BMRoom);
-    /**
-     * 发送聊天消息
-     * @param talkMsg 聊天信息
-     */
-    sendMessage(talkMsg: string, userId: string | undefined, lostNet: boolean): Promise<void>;
-    addMessage(info: BMMessageInfo, isParticipantNotice: boolean): void;
-    notificationMessageList: any;
-    updateMessageListWatcher(messageList: Array<BMMessageInfo>): void;
-    /**
-     * 获取历史消息
-     */
-    getHistoryMessage(): Promise<BMMessageInfo[]>;
-}

package/umd/boom-meeting/src/BMChat/BMMessageInfo.d.ts

@@ -1,31 +0,0 @@
-interface IMessageInfo {
-    userId?: string;
-    message: string;
-    role?: string;
-    isLocal?: boolean;
-    avatar?: string;
-    nickName?: string;
-    sendTime?: number;
-    isMeetingNotice?: boolean;
-    to?: string | undefined;
-    isDanger?: boolean;
-    seq?: number;
-    failed?: boolean;
-}
-export default class BMMessageInfo {
-    userId?: any;
-    message: string;
-    time: string;
-    timeStamp: number;
-    role?: string;
-    isLocal?: boolean;
-    avatar?: any;
-    nickName?: any;
-    isMeetingNotice: boolean;
-    to: string | undefined;
-    isDanger: boolean | undefined;
-    seq: number | undefined;
-    failed: boolean | undefined;
-    constructor(props: IMessageInfo);
-}
-export {};

package/umd/boom-meeting/src/BMRoom/BMLiveVM.d.ts

@@ -1,35 +0,0 @@
-/**
- * @name: BMLiveVM.ts
- * @author: yangliye
- * @date: 2022-07-15 13:53
- * @description：处理直播相关的流处理
- * @update: 2022-07-15 13:53
- */
-import BMRoom from "./BMRoom";
-import BMStreamModel from "../BMStream/BMStreamModel";
-declare class BMLiveVM {
-    private room;
-    constructor(room: BMRoom);
-    private get localBMUser();
-    private get localIsAudience();
-    /**
-     * 拉流处理
-     * @param bmStreamModel
-     */
-    handlePull(bmStreamModel: BMStreamModel): Promise<void>;
-    /**
-     * 切换大小流处理
-     * @param bmStreamModel
-     */
-    handleChangeStreamType(bmStreamModel: BMStreamModel): Promise<void>;
-    handlePlay(bmStreamModel: BMStreamModel, noPlayChanged: boolean): Promise<void>;
-    /**
-     * 处理观众端举手发言完了，然后在禁止发言，这个时候，没有必要在拉所有人的流，把除了混流的人的流都取消订阅，然后播放混流的声音
-     */
-    handleAudienceDisable(): Promise<void>;
-    /**
-     * 观众允许发言，允许发言之后，要把所有的流都拉，然后混流静音
-     */
-    handleAudienceEnable(): Promise<void>;
-}
-export default BMLiveVM;