@tencentcloud/roomkit-electron-vue3 2.4.2 → 2.6.0

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

@@ -0,0 +1,40 @@
+interface JoinParams {
+    roomId: string;
+    roomParam?: {
+        isOpenCamera?: boolean;
+        isOpenMicrophone?: boolean;
+    };
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    isShowScheduledConference?: boolean;
+}>, {
+    isShowScheduledConference: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "join-conference": (options: JoinParams) => void;
+}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    isShowScheduledConference?: boolean;
+}>, {
+    isShowScheduledConference: boolean;
+}>>> & {
+    "onJoin-conference"?: ((options: JoinParams) => any) | undefined;
+}, {
+    isShowScheduledConference: boolean;
+}, {}>;
+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;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const ScheduleRoomList_vue_vue_type_script_setup_true_lang = require("./ScheduleRoomList.vue2.js");
+;/* empty css                       */
+const _pluginVue_exportHelper = require("../../_virtual/_plugin-vue_export-helper.js");
+const ScheduleRoomList = /* @__PURE__ */ _pluginVue_exportHelper.default(ScheduleRoomList_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-75d7e1dc"]]);
+exports.default = ScheduleRoomList;

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

@@ -0,0 +1,257 @@
+"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 = {
+  key: 0,
+  class: "schedule-loading"
+};
+const _hoisted_2 = { class: "text" };
+const _hoisted_3 = {
+  key: 0,
+  class: "schedule-room-container"
+};
+const _hoisted_4 = {
+  key: 0,
+  class: "schedule-room-date"
+};
+const _hoisted_5 = {
+  key: 1,
+  class: "schedule-no-body"
+};
+const _hoisted_6 = { 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;
+    function sortScheduleRoomList() {
+      return scheduleRoomList.value.sort(
+        (a, b) => a.scheduleStartTime - b.scheduleStartTime
+      );
+    }
+    const sortedScheduleRoomList = Vue.computed(() => sortScheduleRoomList());
+    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) => {
+      const attendeeList = await fetchAttendeeList(data.roomId);
+      const scheduleRoom = scheduleRoomList.value.find(
+        (item) => item.basicRoomInfo.roomId === data.roomId
+      );
+      if (scheduleRoom) {
+        scheduleRoom.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", {
+        id: "scheduleRoomContainer",
+        class: Vue.normalizeClass([
+          "schedule-room",
+          !Vue.unref(environment.isMobile) ? "schedule-room-pc" : "schedule-room-h5"
+        ])
+      }, [
+        isShowLoading.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, [
+          Vue.createVNode(SvgIcon.default, {
+            icon: LoadingScheduleIcon.default,
+            class: "loading"
+          }),
+          Vue.createElementVNode("span", _hoisted_2, Vue.toDisplayString(Vue.unref(t)("Schedule room loading")), 1)
+        ])) : (Vue.openBlock(), Vue.createElementBlock(Vue.Fragment, { key: 1 }, [
+          scheduleRoomList.value.length > 0 ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_3, [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(scheduleContentList.value, (item) => {
+              return Vue.openBlock(), Vue.createElementBlock("div", {
+                key: item.basicRoomInfo.roomId
+              }, [
+                item.showTimestamp ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_4, [
+                  Vue.createVNode(SvgIcon.default, {
+                    class: "date",
+                    icon: CalendarIcon.default
+                  }),
+                  Vue.createElementVNode("span", null, Vue.toDisplayString(getScheduleDate(item.scheduleStartTime)), 1)
+                ])) : Vue.createCommentVNode("", true),
+                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: handleShowMore
+                }, null, 8, ["item", "schedule-start-date", "schedule-end-date", "schedule-start-time", "schedule-end-time"])
+              ]);
+            }), 128))
+          ])) : (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_5, [
+            Vue.createVNode(SvgIcon.default, { icon: ApplyStageLabelIcon.default }),
+            Vue.createElementVNode("span", _hoisted_6, Vue.toDisplayString(Vue.unref(t)("No room available for booking")), 1)
+          ]))
+        ], 64))
+      ], 2)), [
+        [Vue.vShow, props.isShowScheduledConference]
+      ]);
+    };
+  }
+});
+exports.default = _sfc_main;

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");
+;/* empty css                */
+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-a4f8d014"]]);
+exports.default = TuiShareLink;

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const pinia = require("pinia");
+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 basic = require("../../stores/basic.js");
+require("../../services/main.js");
+const roomService = require("../../services/roomService.js");
+require("@tencentcloud/tuiroom-engine-electron");
+require("mitt");
+require("../../services/manager/roomActionManager.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 basicStore = basic.useBasicStore();
+    const { isRoomLinkVisible } = pinia.storeToRefs(basicStore);
+    const roomLinkConfig = roomService.roomService.getComponentConfig("RoomLink");
+    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")}`
+    );
+    const isShowPassword = Vue.computed(() => !!props.scheduleParams.password);
+    function copyRoomIdAndRoomLink() {
+      const invitationList = [
+        `${props.scheduleParams.roomName}`,
+        `${t("Room Type")}: ${roomType.value}`,
+        `${t("Room ID")}: ${props.scheduleParams.roomId}`
+      ];
+      if (isShowPassword.value) {
+        invitationList.push(
+          `${t("Room Password")}: ${props.scheduleParams.password}`
+        );
+      }
+      if (isRoomLinkVisible.value && roomLinkConfig.visible) {
+        invitationList.push(
+          `${t("Room Link")}: ${utils.getUrlWithRoomId(props.scheduleParams.roomId)}`
+        );
+      }
+      const invitation = invitationList.join("\n");
+      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/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,165 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index = require("../common/base/Select/index.vue.js");
+const index$1 = require("../common/base/Option/index.vue.js");
+const common = require("../../utils/common.js");
+require("../../services/main.js");
+const roomService = require("../../services/roomService.js");
+const types = require("../../services/types.js");
+require("../../locales/index.js");
+require("@tencentcloud/tuiroom-engine-electron");
+require("mitt");
+require("../../services/manager/roomActionManager.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 currentLanguage = Vue.ref(common.getLanguage());
+    const timeOptions = Vue.computed(() => {
+      switch (currentLanguage.value) {
+        case "zh-CN":
+          return timeOptionsCh.value;
+        case "en-US":
+          return timeOptionsEn.value;
+        default:
+          return timeOptionsEn.value;
+      }
+    });
+    const timeOptionsCh = 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 timeOptionsEn = Vue.computed(() => [
+      { label: "GMT-12:00 International Date Line West", value: "Etc/GMT+12" },
+      { label: "GMT-11:00 Coordinated Universal Time-11", value: "Etc/GMT+11" },
+      {
+        label: "GMT-10:00 Hawaii-Aleutian Standard Time",
+        value: "Pacific/Honolulu"
+      },
+      { label: "GMT-09:00 Alaska Standard Time", value: "America/Anchorage" },
+      { label: "GMT-08:00 Pacific Standard Time", value: "America/Los_Angeles" },
+      { label: "GMT-07:00 Mountain Standard Time", value: "America/Denver" },
+      { label: "GMT-06:00 Central Standard Time", value: "America/Chicago" },
+      { label: "GMT-05:00 Eastern Standard Time", value: "America/New_York" },
+      { label: "GMT-04:00 Atlantic Standard Time", value: "America/Halifax" },
+      {
+        label: "GMT-03:00 Argentina Standard Time",
+        value: "America/Argentina/Buenos_Aires"
+      },
+      { label: "GMT-02:00 Coordinated Universal Time-02", value: "Etc/GMT+2" },
+      { label: "GMT-01:00 Cape Verde Standard Time", value: "Atlantic/Cape_Verde" },
+      { label: "GMT+00:00 Greenwich Mean Time", value: "Europe/London" },
+      { label: "GMT+01:00 Central European Standard Time", value: "Europe/Berlin" },
+      { label: "GMT+02:00 Eastern European Standard Time", value: "Europe/Kiev" },
+      { label: "GMT+03:00 Moscow Standard Time", value: "Europe/Moscow" },
+      { label: "GMT+04:00 Gulf Standard Time", value: "Asia/Dubai" },
+      { label: "GMT+05:00 Pakistan Standard Time", value: "Asia/Karachi" },
+      { label: "GMT+05:30 Indian Standard Time", value: "Asia/Kolkata" },
+      { label: "GMT+06:00 Bangladesh Standard Time", value: "Asia/Dhaka" },
+      { label: "GMT+07:00 Indochina Time", value: "Asia/Bangkok" },
+      { label: "GMT+08:00 China Standard Time - Beijing", value: "Asia/Shanghai" },
+      { label: "GMT+09:00 Japan Standard Time", value: "Asia/Tokyo" },
+      {
+        label: "GMT+10:00 Australian Eastern Standard Time - Sydney",
+        value: "Australia/Sydney"
+      },
+      {
+        label: "GMT+11:00 Solomon Islands Standard Time",
+        value: "Pacific/Guadalcanal"
+      },
+      { label: "GMT+12:00 New Zealand Standard Time", value: "Pacific/Auckland" },
+      { label: "GMT+13:00 Tonga Standard Time", value: "Pacific/Tongatapu" }
+    ]);
+    const handleLanguageChange = async (language) => {
+      currentLanguage.value = language;
+    };
+    Vue.onMounted(() => {
+      roomService.roomService.on(types.EventType.LANGUAGE_CHANGED, handleLanguageChange);
+    });
+    Vue.onUnmounted(() => {
+      roomService.roomService.off(types.EventType.LANGUAGE_CHANGED, handleLanguageChange);
+    });
+    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(index.default, {
+          modelValue: selectedTime.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectedTime.value = $event),
+          theme: "white",
+          teleported: false,
+          "custom-select-content-style": { "font-weight": 400 },
+          value: selectedTime.value,
+          onInput: _cache[1] || (_cache[1] = ($event) => selectedTime.value = $event)
+        }, {
+          default: Vue.withCtx(() => [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(timeOptions.value, (time) => {
+              return Vue.openBlock(), Vue.createBlock(index$1.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", "value"])
+      ]);
+    };
+  }
+});
+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;