@tencentcloud/roomkit-electron-vue3 2.4.1 → 2.5.0

package/lib/components/ScheduleConference/ScheduleRoomList.vue2.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+require("../../services/main.js");
+const roomService = require("../../services/roomService.js");
+const types = require("../../services/types.js");
+const index = require("../../locales/index.js");
+const TUIRoomEngine = require("@tencentcloud/tuiroom-engine-electron");
+require("mitt");
+require("../../services/manager/roomActionManager.js");
+const SvgIcon = require("../common/base/SvgIcon.vue.js");
+const CalendarIcon = require("../common/icons/CalendarIcon.vue.js");
+const ApplyStageLabelIcon = require("../common/icons/ApplyStageLabelIcon.vue.js");
+const ScheduleRoomControl = require("./ScheduleRoomControl.vue.js");
+const LoadingScheduleIcon = require("../common/icons/LoadingScheduleIcon.vue.js");
+const environment = require("../../utils/environment.js");
+const utils = require("../../utils/utils.js");
+const _hoisted_1 = {
+  id: "scheduleRoomContainer",
+  class: "schedule-room"
+};
+const _hoisted_2 = {
+  key: 0,
+  class: "schedule-loading"
+};
+const _hoisted_3 = { class: "text" };
+const _hoisted_4 = { key: 1 };
+const _hoisted_5 = {
+  key: 0,
+  class: "schedule-room-container"
+};
+const _hoisted_6 = { class: "schedule-room-date" };
+const _hoisted_7 = {
+  key: 1,
+  class: "schedule-no-body"
+};
+const _hoisted_8 = { class: "text" };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "ScheduleRoomList",
+  props: {
+    isShowScheduledConference: { type: Boolean, default: true }
+  },
+  emits: ["join-conference"],
+  setup(__props, { emit: __emit }) {
+    const { t } = index.useI18n();
+    const scheduleRoomList = Vue.ref([]);
+    const emit = __emit;
+    const isShowLoading = Vue.ref(true);
+    const joinConference = (options) => {
+      emit("join-conference", options);
+    };
+    const props = __props;
+    const sortedScheduleRoomList = Vue.computed(() => scheduleRoomList.value.sort((a, b) => a.scheduleStartTime - b.scheduleStartTime));
+    const fetchScheduledData = async (cursor = "", result = []) => {
+      const res = await roomService.roomService.scheduleConferenceManager.fetchScheduledConferenceList({
+        cursor,
+        count: 20
+      });
+      (res == null ? void 0 : res.conferenceList) && result.push(...res == null ? void 0 : res.conferenceList);
+      if (res.cursor !== "") {
+        await fetchScheduledData(res.cursor, result);
+      }
+      return result;
+    };
+    const scheduleContentList = Vue.computed(() => sortedScheduleRoomList.value.map((item, index2, arr) => {
+      if (index2 === 0 || getScheduleDate(item.scheduleStartTime) !== getScheduleDate(arr[index2 - 1].scheduleStartTime)) {
+        return { ...item, showTimestamp: true };
+      }
+      return { ...item, showTimestamp: false };
+    }));
+    function getScheduleDate(timestamp) {
+      const date = new Date(timestamp * 1e3);
+      const year = `${date.getFullYear()}`;
+      const month = `${date.getMonth() + 1 < 10 ? `0${date.getMonth() + 1}` : date.getMonth() + 1}`;
+      const day = `${date.getDate() < 10 ? `0${date.getDate()}` : date.getDate()}`;
+      return `${year}${t("schedule year")}${month}${t("schedule month")}${day}${t("schedule day")}`;
+    }
+    function getScheduleTime(timestamp) {
+      const date = new Date(timestamp * 1e3);
+      const hours = `${date.getHours() < 10 ? `0${date.getHours()}` : date.getHours()}`;
+      const minutes = `${date.getMinutes() < 10 ? `0${date.getMinutes()}` : date.getMinutes()}`;
+      return `${hours}:${minutes}`;
+    }
+    const fetchAttendeeList = async (roomId, cursor = "", result = []) => {
+      const res = await roomService.roomService.scheduleConferenceManager.fetchAttendeeList({ roomId, cursor, count: 20 });
+      if (!(res == null ? void 0 : res.attendeeList))
+        return [];
+      result.push(...res == null ? void 0 : res.attendeeList);
+      if (res.cursor !== "") {
+        await fetchAttendeeList(roomId, res.cursor, result);
+      }
+      return result;
+    };
+    const handleShowMore = async (data, index2) => {
+      const attendeeList = await fetchAttendeeList(data.roomId);
+      scheduleRoomList.value[index2].scheduleAttendees = attendeeList;
+    };
+    const fetchData = async () => {
+      scheduleRoomList.value = await fetchScheduledData();
+      isShowLoading.value = false;
+    };
+    const updateAttendees = (originList = [], changeData) => {
+      const { joinedUsers, leftUsers } = changeData;
+      let resultList = [...originList, ...joinedUsers];
+      resultList = resultList.filter((attendee) => !leftUsers.some((leftUser) => leftUser.userId === attendee.userId));
+      return resultList;
+    };
+    const onConferenceScheduled = async (data) => {
+      const { conferenceInfo } = data;
+      scheduleRoomList.value.push(conferenceInfo);
+    };
+    const onConferenceCancelled = async (data) => {
+      scheduleRoomList.value = scheduleRoomList.value.filter((item) => item.basicRoomInfo.roomId !== data.roomId);
+    };
+    const onConferenceInfoChanged = async (data) => {
+      const aimConferenceIndex = scheduleRoomList.value.findIndex((item) => item.basicRoomInfo.roomId === data.conferenceModifyInfo.basicRoomInfo.roomId);
+      if (aimConferenceIndex !== -1) {
+        scheduleRoomList.value[aimConferenceIndex] = utils.objectMerge(
+          scheduleRoomList.value[aimConferenceIndex],
+          data.conferenceModifyInfo
+        );
+      }
+    };
+    const onScheduleAttendeesChanged = async (data) => {
+      const aimConference = scheduleRoomList.value.find((item) => item.basicRoomInfo.roomId === data.roomId);
+      if (aimConference) {
+        aimConference.scheduleAttendees = updateAttendees(aimConference.scheduleAttendees, data);
+      }
+    };
+    const onConferenceStatusChanged = (data) => {
+      const aimConference = scheduleRoomList.value.find((item) => item.basicRoomInfo.roomId === data.roomId);
+      if (aimConference) {
+        aimConference.status = data.status;
+      }
+    };
+    Vue.onMounted(() => {
+      roomService.roomService.on(types.EventType.ROOM_LOGIN, fetchData);
+      roomService.roomService.scheduleConferenceManager.on(TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceScheduled, onConferenceScheduled);
+      roomService.roomService.scheduleConferenceManager.on(TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceCancelled, onConferenceCancelled);
+      roomService.roomService.scheduleConferenceManager.on(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceInfoChanged,
+        onConferenceInfoChanged
+      );
+      roomService.roomService.scheduleConferenceManager.on(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+        onScheduleAttendeesChanged
+      );
+      roomService.roomService.scheduleConferenceManager.on(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceStatusChanged,
+        onConferenceStatusChanged
+      );
+    });
+    Vue.onUnmounted(() => {
+      roomService.roomService.off(types.EventType.ROOM_LOGIN, fetchData);
+      roomService.roomService.scheduleConferenceManager.off(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceScheduled,
+        onConferenceScheduled
+      );
+      roomService.roomService.scheduleConferenceManager.off(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceCancelled,
+        onConferenceCancelled
+      );
+      roomService.roomService.scheduleConferenceManager.off(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceInfoChanged,
+        onConferenceInfoChanged
+      );
+      roomService.roomService.scheduleConferenceManager.off(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+        onScheduleAttendeesChanged
+      );
+      roomService.roomService.scheduleConferenceManager.off(
+        TUIRoomEngine.TUIConferenceListManagerEvents.onConferenceStatusChanged,
+        onConferenceStatusChanged
+      );
+    });
+    return (_ctx, _cache) => {
+      return Vue.withDirectives((Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, [
+        isShowLoading.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_2, [
+          Vue.createVNode(SvgIcon.default, {
+            icon: LoadingScheduleIcon.default,
+            class: "loading"
+          }),
+          Vue.createElementVNode("span", _hoisted_3, Vue.toDisplayString(Vue.unref(t)("Schedule room loading")), 1)
+        ])) : (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_4, [
+          scheduleRoomList.value.length > 0 ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_5, [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(scheduleContentList.value, (item, index2) => {
+              return Vue.openBlock(), Vue.createElementBlock("div", { key: index2 }, [
+                Vue.withDirectives(Vue.createElementVNode("div", _hoisted_6, [
+                  Vue.createVNode(SvgIcon.default, {
+                    class: "date",
+                    icon: CalendarIcon.default
+                  }),
+                  Vue.createElementVNode("span", null, Vue.toDisplayString(getScheduleDate(item.scheduleStartTime)), 1)
+                ], 512), [
+                  [Vue.vShow, item.showTimestamp]
+                ]),
+                Vue.createVNode(ScheduleRoomControl.default, {
+                  item,
+                  "schedule-start-date": getScheduleDate(item.scheduleStartTime),
+                  "schedule-end-date": getScheduleDate(item.scheduleEndTime),
+                  "schedule-start-time": getScheduleTime(item.scheduleStartTime),
+                  "schedule-end-time": getScheduleTime(item.scheduleEndTime),
+                  onJoinConference: joinConference,
+                  onShowMore: (data) => handleShowMore(data, index2)
+                }, null, 8, ["item", "schedule-start-date", "schedule-end-date", "schedule-start-time", "schedule-end-time", "onShowMore"])
+              ]);
+            }), 128))
+          ])) : (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_7, [
+            Vue.createVNode(SvgIcon.default, { icon: ApplyStageLabelIcon.default }),
+            Vue.createElementVNode("span", _hoisted_8, Vue.toDisplayString(Vue.unref(t)("No room available for booking")), 1)
+          ]))
+        ]))
+      ], 512)), [
+        [Vue.vShow, props.isShowScheduledConference && !Vue.unref(environment.isMobile)]
+      ]);
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/components/ScheduleConference/ScheduleRoomList.vue3.js

@@ -0,0 +1 @@
+"use strict";

package/lib/components/ScheduleConference/ShareLink.vue.d.ts

@@ -0,0 +1,24 @@
+import { TUIConferenceInfo } from '@tencentcloud/tuiroom-engine-electron';
+
+interface Props {
+    conferenceInfo?: TUIConferenceInfo;
+    scheduleParams?: any;
+    visible: boolean;
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<Props>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+    close: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<Props>>> & {
+    onInput?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/lib/components/ScheduleConference/ShareLink.vue.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const ShareLink_vue_vue_type_script_setup_true_lang = require("./ShareLink.vue2.js");
+require("./ShareLink.vue3.js");
+const _pluginVue_exportHelper = require("../../_virtual/_plugin-vue_export-helper.js");
+const TuiShareLink = /* @__PURE__ */ _pluginVue_exportHelper.default(ShareLink_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-2d9808e2"]]);
+exports.default = TuiShareLink;

package/lib/components/ScheduleConference/ShareLink.vue2.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index = require("../../locales/index.js");
+const index$1 = require("../common/base/Dialog/index.vue.js");
+const Button = require("../common/base/Button.vue.js");
+const SuccessIcon = require("../common/icons/SuccessIcon.vue.js");
+const CopyIcon = require("../common/icons/CopyIcon.vue.js");
+const SvgIcon = require("../common/base/SvgIcon.vue.js");
+const useRoomInfoHooks = require("../RoomHeader/RoomInfo/useRoomInfoHooks.js");
+const utils = require("../../utils/utils.js");
+const _hoisted_1 = { class: "invite-member" };
+const _hoisted_2 = { class: "invite-member-title" };
+const _hoisted_3 = { class: "invite-member-item" };
+const _hoisted_4 = { class: "invite-member-content" };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "ShareLink",
+  props: {
+    conferenceInfo: {},
+    scheduleParams: {},
+    visible: { type: Boolean }
+  },
+  emits: ["input", "close"],
+  setup(__props, { emit: __emit }) {
+    const { t } = index.useI18n();
+    const { onCopy } = useRoomInfoHooks.default();
+    const props = __props;
+    const emit = __emit;
+    const showRoomInvite = Vue.ref(false);
+    Vue.watch(
+      () => props.visible,
+      (val) => {
+        showRoomInvite.value = val;
+      },
+      {
+        immediate: true
+      }
+    );
+    const updateVisible = (val) => {
+      emit("input", val);
+    };
+    const roomType = Vue.computed(() => props.scheduleParams.isSeatEnabled ? `${t("On-stage Speaking Room")}` : `${t("Free Speech Room")}`);
+    function copyRoomIdAndRoomLink() {
+      const invitation = `${props.scheduleParams.roomName}
+
+${t("Room Type")}: ${roomType.value}
+
+${t("Room Time")}: ${new Date(props.scheduleParams.scheduleStartTime * 1e3)} - ${new Date(props.scheduleParams.scheduleEndTime * 1e3)}
+
+${t("Room ID")}: ${props.scheduleParams.roomId}
+
+${t("Room Link")}: ${utils.getUrlWithRoomId(props.scheduleParams.roomId)}`;
+      onCopy(invitation);
+    }
+    const scheduleInviteList = Vue.computed(() => [
+      { id: 1, title: `${t("Invitation by room ID")}`, content: props.scheduleParams.roomId },
+      { id: 2, title: `${t("Invitation via room link")}`, content: utils.getUrlWithRoomId(props.scheduleParams.roomId) }
+    ]);
+    Vue.watch(showRoomInvite, (val) => {
+      updateVisible(val);
+    }, { immediate: true });
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createBlock(index$1.default, {
+        modelValue: showRoomInvite.value,
+        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => showRoomInvite.value = $event),
+        title: Vue.unref(t)("Schedule successful, invite members to join"),
+        modal: true,
+        "show-close": true,
+        "close-on-click-modal": true,
+        width: "540px",
+        "append-to-body": true,
+        "title-icon": SuccessIcon.default
+      }, {
+        footer: Vue.withCtx(() => [
+          Vue.createElementVNode("span", null, [
+            Vue.createVNode(Button.default, {
+              class: "dialog-button",
+              size: "default",
+              onClick: _cache[0] || (_cache[0] = ($event) => copyRoomIdAndRoomLink())
+            }, {
+              default: Vue.withCtx(() => [
+                Vue.createTextVNode(Vue.toDisplayString(Vue.unref(t)("Copy the conference number and link")), 1)
+              ]),
+              _: 1
+            })
+          ])
+        ]),
+        default: Vue.withCtx(() => [
+          Vue.createElementVNode("div", _hoisted_1, [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(scheduleInviteList.value, (item) => {
+              return Vue.openBlock(), Vue.createElementBlock("div", {
+                key: item.id,
+                class: "invite-member-container"
+              }, [
+                Vue.createElementVNode("div", _hoisted_2, Vue.toDisplayString(Vue.unref(t)(item.title)), 1),
+                Vue.createElementVNode("div", _hoisted_3, [
+                  Vue.createElementVNode("span", _hoisted_4, Vue.toDisplayString(item.content), 1),
+                  Vue.createVNode(SvgIcon.default, {
+                    class: "copy",
+                    icon: CopyIcon.default,
+                    onClick: ($event) => Vue.unref(onCopy)(item.content)
+                  }, null, 8, ["onClick"])
+                ])
+              ]);
+            }), 128))
+          ])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "title"]);
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/components/ScheduleConference/ShareLink.vue3.js

@@ -0,0 +1 @@
+"use strict";

package/lib/components/ScheduleConference/TimezonePicker.vue.d.ts

@@ -0,0 +1,18 @@
+interface Props {
+    modelValue: string;
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<Props>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<Props>>> & {
+    onInput?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/lib/components/ScheduleConference/TimezonePicker.vue.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const Select = require("../common/base/Select.vue.js");
+const Option = require("../common/base/Option.vue.js");
+const _hoisted_1 = { class: "container" };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "TimezonePicker",
+  props: {
+    modelValue: {}
+  },
+  emits: ["input"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const selectedTime = Vue.ref(props.modelValue);
+    const timeOptions = Vue.computed(() => [
+      { label: "GMT-12:00 世界时 - 国际日期变更线西", value: "Etc/GMT+12" },
+      { label: "GMT-11:00 世界时 - 协调世界时-11", value: "Etc/GMT+11" },
+      { label: "GMT-10:00 夏威夷 - 阿留申标准时间", value: "Pacific/Honolulu" },
+      { label: "GMT-09:00 阿拉斯加标准时间", value: "America/Anchorage" },
+      { label: "GMT-08:00 太平洋标准时间", value: "America/Los_Angeles" },
+      { label: "GMT-07:00 美国山地标准时间", value: "America/Denver" },
+      { label: "GMT-06:00 美国中部标准时间", value: "America/Chicago" },
+      { label: "GMT-05:00 美国东部标准时间", value: "America/New_York" },
+      { label: "GMT-04:00 大西洋标准时间", value: "America/Halifax" },
+      { label: "GMT-03:00 阿根廷标准时间", value: "America/Argentina/Buenos_Aires" },
+      { label: "GMT-02:00 协调世界时-02", value: "Etc/GMT+2" },
+      { label: "GMT-01:00 佛得角标准时间", value: "Atlantic/Cape_Verde" },
+      { label: "GMT+00:00 格林威治标准时间", value: "Europe/London" },
+      { label: "GMT+01:00 中欧标准时间", value: "Europe/Berlin" },
+      { label: "GMT+02:00 东欧标准时间", value: "Europe/Kiev" },
+      { label: "GMT+03:00 莫斯科标准时间", value: "Europe/Moscow" },
+      { label: "GMT+04:00 阿布扎比标准时间", value: "Asia/Dubai" },
+      { label: "GMT+05:00 巴基斯坦标准时间", value: "Asia/Karachi" },
+      { label: "GMT+05:30 印度标准时间", value: "Asia/Kolkata" },
+      { label: "GMT+06:00 孟加拉国标准时间", value: "Asia/Dhaka" },
+      { label: "GMT+07:00 泰国标准时间", value: "Asia/Bangkok" },
+      { label: "GMT+08:00 中国标准时间 - 北京", value: "Asia/Shanghai" },
+      { label: "GMT+09:00 日本标准时间", value: "Asia/Tokyo" },
+      { label: "GMT+10:00 澳大利亚东部标准时间 - 悉尼", value: "Australia/Sydney" },
+      { label: "GMT+11:00 所罗门群岛标准时间", value: "Pacific/Guadalcanal" },
+      { label: "GMT+12:00 新西兰标准时间", value: "Pacific/Auckland" },
+      { label: "GMT+13:00 汤加标准时间", value: "Pacific/Tongatapu" }
+    ]);
+    const updateTime = () => {
+      emit("input", selectedTime.value);
+    };
+    Vue.watch(selectedTime, () => {
+      updateTime();
+    }, {
+      immediate: true
+    });
+    Vue.watch(() => props.modelValue, (newValue) => {
+      selectedTime.value = newValue;
+    }, { immediate: true });
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, [
+        Vue.createVNode(Select.default, {
+          modelValue: selectedTime.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectedTime.value = $event),
+          theme: "white",
+          class: "timepicker-select",
+          teleported: false,
+          "custom-select-content-style": { "font-weight": 400 }
+        }, {
+          default: Vue.withCtx(() => [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(timeOptions.value, (time) => {
+              return Vue.openBlock(), Vue.createBlock(Option.default, {
+                key: time.value,
+                theme: "white",
+                value: time.value,
+                label: time.label,
+                "custom-option-content-style": { "font-weight": 400 }
+              }, null, 8, ["value", "label"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["modelValue"])
+      ]);
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/components/ScheduleConference/TimezonePicker.vue2.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const TimezonePicker_vue_vue_type_script_setup_true_lang = require("./TimezonePicker.vue.js");
+exports.default = TimezonePicker_vue_vue_type_script_setup_true_lang.default;

package/lib/components/common/Avatar.vue.js

@@ -3,5 +3,5 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const Avatar_vue_vue_type_script_setup_true_lang = require("./Avatar.vue2.js");
 require("./Avatar.vue3.js");
 const _pluginVue_exportHelper = require("../../_virtual/_plugin-vue_export-helper.js");
-const Avatar = /* @__PURE__ */ _pluginVue_exportHelper.default(Avatar_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-94a403fe"]]);
-exports.default = Avatar;
+const TuiAvatar = /* @__PURE__ */ _pluginVue_exportHelper.default(Avatar_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-94a403fe"]]);
+exports.default = TuiAvatar;

package/lib/components/common/DeviceSelect.vue.js

@@ -3,5 +3,5 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const DeviceSelect_vue_vue_type_script_setup_true_lang = require("./DeviceSelect.vue2.js");
 require("./DeviceSelect.vue3.js");
 const _pluginVue_exportHelper = require("../../_virtual/_plugin-vue_export-helper.js");
-const DeviceSelect = /* @__PURE__ */ _pluginVue_exportHelper.default(DeviceSelect_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-21a1edd5"]]);
+const DeviceSelect = /* @__PURE__ */ _pluginVue_exportHelper.default(DeviceSelect_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-0cca651b"]]);
 exports.default = DeviceSelect;

package/lib/components/common/DeviceSelect.vue2.js

@@ -30,16 +30,37 @@ const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
     const currentDeviceId = Vue.ref(getInitDeviceId());
     function getInitDeviceId() {
       if (deviceType === "camera") {
-        return currentCameraId;
+        return currentCameraId.value;
       }
       if (deviceType === "microphone") {
-        return currentMicrophoneId;
+        return currentMicrophoneId.value;
       }
       if (deviceType === "speaker") {
-        return currentSpeakerId;
+        return currentSpeakerId.value;
       }
       return "";
     }
+    if (deviceType === "camera") {
+      Vue.watch(currentCameraId, (val) => {
+        if (currentDeviceId.value !== val) {
+          currentDeviceId.value = val;
+        }
+      }, { immediate: true });
+    }
+    if (deviceType === "microphone") {
+      Vue.watch(currentMicrophoneId, (val) => {
+        if (currentDeviceId.value !== val) {
+          currentDeviceId.value = val;
+        }
+      }, { immediate: true });
+    }
+    if (deviceType === "speaker") {
+      Vue.watch(currentSpeakerId, (val) => {
+        if (currentDeviceId.value !== val) {
+          currentDeviceId.value = val;
+        }
+      }, { immediate: true });
+    }
     function getDeviceList() {
       if (deviceType === "camera") {
         return cameraList;
@@ -57,25 +78,43 @@ const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
       onChange && onChange(deviceId);
       switch (deviceType) {
         case "camera":
-          await ((_a = deviceManager.instance) == null ? void 0 : _a.setCurrentDevice({
-            type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeVideoCamera,
-            deviceId
-          }));
-          roomStore.setCurrentCameraId(deviceId);
+          try {
+            await ((_a = deviceManager.instance) == null ? void 0 : _a.setCurrentDevice({
+              type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeVideoCamera,
+              deviceId
+            }));
+            roomStore.setCurrentCameraId(deviceId);
+          } catch (error) {
+            if (cameraList.value.map((item) => item.deviceId).includes(currentCameraId.value)) {
+              currentDeviceId.value = currentCameraId.value;
+            }
+          }
           break;
         case "microphone":
-          await ((_b = deviceManager.instance) == null ? void 0 : _b.setCurrentDevice({
-            type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeAudioInput,
-            deviceId
-          }));
-          roomStore.setCurrentMicrophoneId(deviceId);
+          try {
+            await ((_b = deviceManager.instance) == null ? void 0 : _b.setCurrentDevice({
+              type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeAudioInput,
+              deviceId
+            }));
+            roomStore.setCurrentMicrophoneId(deviceId);
+          } catch (error) {
+            if (microphoneList.value.map((item) => item.deviceId).includes(currentMicrophoneId.value)) {
+              currentDeviceId.value = currentMicrophoneId.value;
+            }
+          }
           break;
         case "speaker":
-          await ((_c = deviceManager.instance) == null ? void 0 : _c.setCurrentDevice({
-            type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeAudioOutput,
-            deviceId
-          }));
-          roomStore.setCurrentSpeakerId(deviceId);
+          try {
+            await ((_c = deviceManager.instance) == null ? void 0 : _c.setCurrentDevice({
+              type: TUIRoomEngine.TUIMediaDeviceType.kMediaDeviceTypeAudioOutput,
+              deviceId
+            }));
+            roomStore.setCurrentSpeakerId(deviceId);
+          } catch (error) {
+            if (speakerList.value.map((item) => item.deviceId).includes(currentSpeakerId.value)) {
+              currentDeviceId.value = currentSpeakerId.value;
+            }
+          }
           break;
       }
     }

package/lib/components/common/Logo.vue.js

@@ -3,5 +3,5 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const Logo_vue_vue_type_script_setup_true_lang = require("./Logo.vue2.js");
 require("./Logo.vue3.js");
 const _pluginVue_exportHelper = require("../../_virtual/_plugin-vue_export-helper.js");
-const Logo = /* @__PURE__ */ _pluginVue_exportHelper.default(Logo_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-a3741d41"]]);
+const Logo = /* @__PURE__ */ _pluginVue_exportHelper.default(Logo_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-a226f6c2"]]);
 exports.default = Logo;

package/lib/components/common/Logo.vue2.js

@@ -26,8 +26,8 @@ const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
   setup(__props) {
     const basicStore = basic.useBasicStore();
     const { defaultTheme } = pinia.storeToRefs(basicStore);
-    const isEN = Vue.computed(() => !environment.isWeChat && index.default.global.locale.value === "en-US");
-    const isZH = Vue.computed(() => environment.isWeChat || index.default.global.locale.value === "zh-CN");
+    const isEN = Vue.computed(() => index.default.global.locale.value === "en-US");
+    const isZH = Vue.computed(() => index.default.global.locale.value === "zh-CN");
     const isBlackTheme = Vue.computed(() => defaultTheme.value === "black");
     const isWhiteTheme = Vue.computed(() => defaultTheme.value === "white");
     return (_ctx, _cache) => {

package/lib/components/common/base/Badge.vue.d.ts

@@ -19,9 +19,9 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
     isDot: boolean;
 }>>>, {
     type: "primary" | "danger";
+    max: number;
     value: string | number;
     hidden: boolean;
-    max: number;
     isDot: boolean;
 }, {}>, {
     default?(_: {}): any;

package/lib/components/common/base/Button.vue.d.ts

@@ -28,10 +28,10 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
     onClick?: ((...args: any[]) => any) | undefined;
 }, {
     size: "default" | "large";
-    type: "text" | "primary" | "success" | "warning" | "danger" | "info";
+    type: "text" | "warning" | "primary" | "success" | "danger" | "info";
     customStyle: string | false | import("vue").CSSProperties | StyleValue[] | null;
-    disabled: boolean;
     loading: boolean;
+    disabled: boolean;
     round: boolean;
 }, {}>, {
     icon?(_: {}): any;