tuikit-atomicx-vue3 0.1.0

package/dist/components/VideoSettingPanel/index.d.ts

@@ -0,0 +1,3 @@
+import { default as VideoSettingPanel } from './index.vue';
+
+export { VideoSettingPanel };

package/dist/components/VideoSettingPanel/index.js

@@ -0,0 +1,80 @@
+import { defineComponent, createElementBlock, openBlock, createCommentVNode, Fragment, createElementVNode, toDisplayString, unref, createVNode } from "vue";
+import CameraSelect from "./CameraSelect.js";
+import VideoProfile from "./VideoProfile.js";
+import VideoPreview from "./VideoPreview.js";
+import { useUIKit } from "@tencentcloud/uikit-base-component-vue3";
+import { _ as _export_sfc } from "../../_plugin-vue_export-helper-1tPrXgE0.js";
+import { addI18n } from "../../i18n/index.js";
+import { resource } from "./i18n/en-US/index.js";
+import { resource as resource$1 } from "./i18n/zh-CN/index.js";
+const _hoisted_1 = { class: "video-setting-panel" };
+const _hoisted_2 = { class: "section" };
+const _hoisted_3 = { class: "section-title" };
+const _hoisted_4 = { class: "row" };
+const _hoisted_5 = { class: "label" };
+const _hoisted_6 = { class: "section" };
+const _hoisted_7 = { class: "section-title" };
+const _hoisted_8 = { class: "preview-container" };
+const _hoisted_9 = {
+  key: 2,
+  class: "section"
+};
+const _hoisted_10 = { class: "section-title" };
+const _hoisted_11 = { class: "row" };
+const _hoisted_12 = { class: "label" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: {
+    cameraSelectVisible: {
+      type: Boolean,
+      default: true
+    },
+    videoPreviewVisible: {
+      type: Boolean,
+      default: true
+    },
+    videoProfileVisible: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup(__props) {
+    const { t } = useUIKit();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.cameraSelectVisible ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          createElementVNode("div", _hoisted_2, [
+            createElementVNode("div", _hoisted_3, toDisplayString(unref(t)("Camera")), 1),
+            createElementVNode("div", _hoisted_4, [
+              createElementVNode("span", _hoisted_5, toDisplayString(unref(t)("Select device")), 1),
+              createVNode(CameraSelect)
+            ])
+          ]),
+          _cache[0] || (_cache[0] = createElementVNode("div", { class: "divider" }, null, -1))
+        ], 64)) : createCommentVNode("", true),
+        __props.videoPreviewVisible ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          createElementVNode("div", _hoisted_6, [
+            createElementVNode("div", _hoisted_7, toDisplayString(unref(t)("Preview")), 1),
+            createElementVNode("div", _hoisted_8, [
+              createVNode(VideoPreview, { class: "video-preview" })
+            ])
+          ]),
+          _cache[1] || (_cache[1] = createElementVNode("div", { class: "divider" }, null, -1))
+        ], 64)) : createCommentVNode("", true),
+        __props.videoProfileVisible ? (openBlock(), createElementBlock("div", _hoisted_9, [
+          createElementVNode("div", _hoisted_10, toDisplayString(unref(t)("Video profile")), 1),
+          createElementVNode("div", _hoisted_11, [
+            createElementVNode("span", _hoisted_12, toDisplayString(unref(t)("Resolution")), 1),
+            createVNode(VideoProfile)
+          ])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-01c8fe83"]]);
+addI18n("en-US", { translation: resource });
+addI18n("zh-CN", { translation: resource$1 });
+export {
+  index as VideoSettingPanel
+};

package/dist/components/VideoSettingPanel/index.vue.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    cameraSelectVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    videoPreviewVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    videoProfileVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    cameraSelectVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    videoPreviewVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    videoProfileVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    cameraSelectVisible: boolean;
+    videoPreviewVisible: boolean;
+    videoProfileVisible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/constants/emoji.d.ts

@@ -0,0 +1,6 @@
+interface IEmojiUrlMap {
+    [key: string]: string;
+}
+declare const emojiBaseUrl = "https://web.sdk.qcloud.com/im/assets/emoji-plugin/";
+declare const emojiUrlMap: IEmojiUrlMap;
+export { emojiUrlMap, emojiBaseUrl };

package/dist/constants/emoji.js

@@ -0,0 +1,69 @@
+const emojiBaseUrl = "https://web.sdk.qcloud.com/im/assets/emoji-plugin/";
+const emojiUrlMap = {
+  "[TUIEmoji_Expect]": "emoji_0@2x.png",
+  "[TUIEmoji_Blink]": "emoji_1@2x.png",
+  "[TUIEmoji_Guffaw]": "emoji_2@2x.png",
+  "[TUIEmoji_KindSmile]": "emoji_3@2x.png",
+  "[TUIEmoji_Haha]": "emoji_4@2x.png",
+  "[TUIEmoji_Cheerful]": "emoji_5@2x.png",
+  "[TUIEmoji_Smile]": "emoji_6@2x.png",
+  "[TUIEmoji_Sorrow]": "emoji_7@2x.png",
+  "[TUIEmoji_Speechless]": "emoji_8@2x.png",
+  "[TUIEmoji_Amazed]": "emoji_9@2x.png",
+  "[TUIEmoji_Complacent]": "emoji_10@2x.png",
+  "[TUIEmoji_Lustful]": "emoji_11@2x.png",
+  "[TUIEmoji_Stareyes]": "emoji_12@2x.png",
+  "[TUIEmoji_Giggle]": "emoji_13@2x.png",
+  "[TUIEmoji_Daemon]": "emoji_14@2x.png",
+  "[TUIEmoji_Rage]": "emoji_15@2x.png",
+  "[TUIEmoji_Yawn]": "emoji_16@2x.png",
+  "[TUIEmoji_TearsLaugh]": "emoji_17@2x.png",
+  "[TUIEmoji_Silly]": "emoji_18@2x.png",
+  "[TUIEmoji_Wail]": "emoji_19@2x.png",
+  "[TUIEmoji_Kiss]": "emoji_20@2x.png",
+  "[TUIEmoji_Trapped]": "emoji_21@2x.png",
+  "[TUIEmoji_Fear]": "emoji_22@2x.png",
+  "[TUIEmoji_BareTeeth]": "emoji_23@2x.png",
+  "[TUIEmoji_FlareUp]": "emoji_24@2x.png",
+  "[TUIEmoji_Tact]": "emoji_25@2x.png",
+  "[TUIEmoji_Shit]": "emoji_26@2x.png",
+  "[TUIEmoji_ShutUp]": "emoji_27@2x.png",
+  "[TUIEmoji_Sigh]": "emoji_28@2x.png",
+  "[TUIEmoji_Hehe]": "emoji_29@2x.png",
+  "[TUIEmoji_Silent]": "emoji_30@2x.png",
+  "[TUIEmoji_Skull]": "emoji_31@2x.png",
+  "[TUIEmoji_Mask]": "emoji_32@2x.png",
+  "[TUIEmoji_Beer]": "emoji_33@2x.png",
+  "[TUIEmoji_Cake]": "emoji_34@2x.png",
+  "[TUIEmoji_RedPacket]": "emoji_35@2x.png",
+  "[TUIEmoji_Bombs]": "emoji_36@2x.png",
+  "[TUIEmoji_Ai]": "emoji_37@2x.png",
+  "[TUIEmoji_Celebrate]": "emoji_38@2x.png",
+  "[TUIEmoji_Bless]": "emoji_39@2x.png",
+  "[TUIEmoji_Flower]": "emoji_40@2x.png",
+  "[TUIEmoji_Watermelon]": "emoji_41@2x.png",
+  "[TUIEmoji_Cow]": "emoji_42@2x.png",
+  "[TUIEmoji_Fool]": "emoji_43@2x.png",
+  "[TUIEmoji_Surprised]": "emoji_44@2x.png",
+  "[TUIEmoji_Askance]": "emoji_45@2x.png",
+  "[TUIEmoji_Monster]": "emoji_46@2x.png",
+  "[TUIEmoji_Pig]": "emoji_47@2x.png",
+  "[TUIEmoji_Coffee]": "emoji_48@2x.png",
+  "[TUIEmoji_Ok]": "emoji_49@2x.png",
+  "[TUIEmoji_Heart]": "emoji_50@2x.png",
+  "[TUIEmoji_Sun]": "emoji_51@2x.png",
+  "[TUIEmoji_Moon]": "emoji_52@2x.png",
+  "[TUIEmoji_Star]": "emoji_53@2x.png",
+  "[TUIEmoji_Rich]": "emoji_54@2x.png",
+  "[TUIEmoji_Fortune]": "emoji_55@2x.png",
+  "[TUIEmoji_857]": "emoji_56@2x.png",
+  "[TUIEmoji_666]": "emoji_57@2x.png",
+  "[TUIEmoji_Prohibit]": "emoji_58@2x.png",
+  "[TUIEmoji_Convinced]": "emoji_59@2x.png",
+  "[TUIEmoji_Knife]": "emoji_60@2x.png",
+  "[TUIEmoji_Like]": "emoji_61@2x.png"
+};
+export {
+  emojiBaseUrl,
+  emojiUrlMap
+};

package/dist/directives/vClickOutside.d.ts

@@ -0,0 +1,5 @@
+declare const vClickOutside: {
+    mounted(el: HTMLElement, binding: any): void;
+    unmounted(el: HTMLElement): void;
+};
+export default vClickOutside;

package/dist/directives/vClickOutside.js

@@ -0,0 +1,30 @@
+const nodeMap = /* @__PURE__ */ new Map();
+const vClickOutside = {
+  mounted(el, binding) {
+    const listenerFunction = (event) => {
+      if (el.contains(event.target)) {
+        return;
+      }
+      if (binding.value && typeof binding.value === "function") {
+        binding.value(event);
+      }
+    };
+    if (!nodeMap.has(el)) {
+      nodeMap.set(el, []);
+    }
+    const nodeCallbackList = nodeMap.get(el);
+    nodeCallbackList.push(listenerFunction);
+    document.addEventListener("click", listenerFunction);
+    document.addEventListener("touchend", listenerFunction);
+  },
+  unmounted(el) {
+    const nodeCallbackList = nodeMap.get(el);
+    nodeCallbackList.forEach((callback) => {
+      document.removeEventListener("click", callback);
+      document.addEventListener("touchend", callback);
+    });
+  }
+};
+export {
+  vClickOutside as default
+};

package/dist/directives/vDblTouch.d.ts

@@ -0,0 +1,12 @@
+declare class DblTouch {
+    dom: HTMLElement;
+    callback: (event?: Event | TouchEvent) => void;
+    constructor(el: HTMLElement, binding: any);
+    executeCallback(event: Event | TouchEvent): void;
+    click(event: Event): void;
+    touchend(event: TouchEvent): void;
+}
+declare const vDblTouch: {
+    mounted(el: HTMLElement, binding: any): DblTouch;
+};
+export default vDblTouch;

package/dist/directives/vDblTouch.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const touchEventMap = /* @__PURE__ */ new Map();
+const clickEventMap = /* @__PURE__ */ new Map();
+const TIME_OUT = 300;
+class DblTouch {
+  constructor(el, binding) {
+    __publicField(this, "dom");
+    __publicField(this, "callback");
+    this.dom = el;
+    this.callback = binding.value;
+    el == null ? void 0 : el.addEventListener("click", (event) => {
+      if (binding.modifiers.stop) {
+        event.stopPropagation();
+      }
+      this.click(event);
+    });
+    el == null ? void 0 : el.addEventListener("touchend", (event) => {
+      if (binding.modifiers.stop) {
+        event.stopPropagation();
+      }
+      this.touchend(event);
+    });
+  }
+  executeCallback(event) {
+    clickEventMap.delete(this.dom);
+    touchEventMap.delete(this.dom);
+    this.callback && this.callback(event);
+  }
+  click(event) {
+    const lastEvent = clickEventMap.get(this.dom);
+    if (lastEvent) {
+      this.executeCallback(event);
+    } else {
+      clickEventMap.set(this.dom, event);
+      setTimeout(() => {
+        clickEventMap.delete(this.dom);
+      }, TIME_OUT);
+    }
+  }
+  touchend(event) {
+    const lastEvent = touchEventMap.get(this.dom);
+    if (lastEvent) {
+      this.executeCallback(event);
+    } else {
+      touchEventMap.set(this.dom, event);
+      setTimeout(() => {
+        touchEventMap.delete(this.dom);
+      }, TIME_OUT);
+    }
+  }
+}
+const vDblTouch = {
+  mounted(el, binding) {
+    return new DblTouch(el, binding);
+  }
+};
+export {
+  vDblTouch as default
+};

package/dist/directives/vTap.d.ts

@@ -0,0 +1,15 @@
+declare class VueTouch {
+    dom: HTMLElement;
+    callback: (event: TouchEvent) => void;
+    isMove: boolean;
+    isInOnceTouch: boolean;
+    isLazyTap: boolean;
+    constructor(el: HTMLElement, binding: any);
+    touchstart(event: TouchEvent): void;
+    touchmove(): void;
+    touchend(event: TouchEvent): void;
+}
+declare const vTap: {
+    mounted(el: HTMLElement, binding: any): VueTouch;
+};
+export default vTap;

package/dist/directives/vTap.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const eventMap = /* @__PURE__ */ new Map();
+const TIME_OUT = 300;
+class VueTouch {
+  constructor(el, binding) {
+    __publicField(this, "dom");
+    __publicField(this, "callback");
+    __publicField(this, "isMove");
+    __publicField(this, "isInOnceTouch");
+    __publicField(this, "isLazyTap");
+    this.dom = el;
+    this.callback = binding.value;
+    this.isLazyTap = binding.modifiers.lazy;
+    this.isMove = false;
+    this.isInOnceTouch = false;
+    el == null ? void 0 : el.addEventListener("touchstart", (event) => {
+      if (binding.modifiers.stop) {
+        event.stopPropagation();
+      }
+      this.touchstart(event);
+    });
+    el == null ? void 0 : el.addEventListener("touchmove", (event) => {
+      if (binding.modifiers.stop) {
+        event.stopPropagation();
+      }
+      this.touchmove();
+    });
+    el == null ? void 0 : el.addEventListener("touchend", (event) => {
+      if (binding.modifiers.stop) {
+        event.stopPropagation();
+      }
+      this.touchend(event);
+    });
+  }
+  touchstart(event) {
+    if (event.touches.length > 1 || this.isInOnceTouch) {
+      return;
+    }
+    this.isMove = false;
+    this.isInOnceTouch = true;
+  }
+  touchmove() {
+    if (!this.isInOnceTouch) {
+      return;
+    }
+    this.isMove = true;
+    this.isInOnceTouch = false;
+  }
+  touchend(event) {
+    if (this.isMove || !this.isInOnceTouch) {
+      return;
+    }
+    this.isInOnceTouch = false;
+    if (this.isLazyTap) {
+      if (eventMap.get(this.dom)) {
+        clearTimeout(eventMap.get(this.dom));
+        eventMap.delete(this.dom);
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.callback(event);
+        eventMap.delete(this.dom);
+      }, TIME_OUT);
+      eventMap.set(this.dom, timer);
+    } else {
+      this.callback(event);
+    }
+  }
+}
+const vTap = {
+  mounted(el, binding) {
+    return new VueTouch(el, binding);
+  }
+};
+export {
+  vTap as default
+};

package/dist/directives/vTouchScale.d.ts

@@ -0,0 +1,9 @@
+/**
+ * <div v-touch-scale="enable"></div>
+ */
+declare const vDblTouch: {
+    mounted(el: HTMLElement, binding: any): void;
+    updated(el: HTMLElement, binding: any): void;
+    beforeUnmount(el: HTMLElement): void;
+};
+export default vDblTouch;

package/dist/directives/vTouchScale.js

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const touchScaleElementMap = /* @__PURE__ */ new Map();
+class TouchScale {
+  constructor(el, binding) {
+    __publicField(this, "touchDom");
+    __publicField(this, "transformDom");
+    __publicField(this, "lastPosition", { x: 0, y: 0 });
+    __publicField(this, "lastCenterPosition", { x: 0, y: 0 });
+    __publicField(this, "lastDistance", 0);
+    __publicField(this, "currentTranslate", { x: 0, y: 0 });
+    __publicField(this, "currentCenterPosition", { x: 0, y: 0 });
+    __publicField(this, "currentScale", 1);
+    __publicField(this, "tempScale", 1);
+    __publicField(this, "tempTranslate", { x: 0, y: 0 });
+    __publicField(this, "isOneFingerControl", false);
+    __publicField(this, "isTwoFingerControl", false);
+    __publicField(this, "isEnabled", false);
+    var _a, _b, _c;
+    this.touchDom = el;
+    this.transformDom = el;
+    this.transformDom.style.transformOrigin = "0 0";
+    this.isEnabled = !!binding.value;
+    this.handleTouchStart = this.handleTouchStart.bind(this);
+    this.handleTouchMove = this.handleTouchMove.bind(this);
+    this.handleTouchEnd = this.handleTouchEnd.bind(this);
+    (_a = this.touchDom) == null ? void 0 : _a.addEventListener("touchstart", this.handleTouchStart, false);
+    (_b = this.touchDom) == null ? void 0 : _b.addEventListener("touchmove", this.handleTouchMove, false);
+    (_c = this.touchDom) == null ? void 0 : _c.addEventListener("touchend", this.handleTouchEnd, false);
+  }
+  updateBinding(binding) {
+    this.isEnabled = !!binding.value;
+  }
+  destroy() {
+    var _a, _b, _c;
+    (_a = this.touchDom) == null ? void 0 : _a.removeEventListener(
+      "touchstart",
+      this.handleTouchStart,
+      false
+    );
+    (_b = this.touchDom) == null ? void 0 : _b.removeEventListener(
+      "touchmove",
+      this.handleTouchMove,
+      false
+    );
+    (_c = this.touchDom) == null ? void 0 : _c.removeEventListener("touchend", this.handleTouchEnd, false);
+  }
+  handleTouchStart(event) {
+    if (!this.isEnabled) {
+      return;
+    }
+    event.preventDefault();
+    if (this.currentScale !== 1) {
+      event.stopPropagation();
+    }
+    if (event.touches.length === 2) {
+      this.handleScaleStart(event);
+      this.isTwoFingerControl = true;
+    }
+    if (event.touches.length === 1) {
+      this.handlePositionStart(event);
+      this.isOneFingerControl = true;
+    }
+  }
+  handleTouchMove(event) {
+    if (!this.isEnabled) {
+      return;
+    }
+    event.preventDefault();
+    if (this.tempScale !== 1) {
+      event.stopPropagation();
+    }
+    if (event.touches.length === 2 && this.isTwoFingerControl) {
+      this.handleScaleMove(event);
+    }
+    if (event.touches.length === 1 && this.isOneFingerControl) {
+      this.handlePositionMove(event);
+    }
+  }
+  handleTouchEnd(event) {
+    if (!this.isEnabled) {
+      return;
+    }
+    event.preventDefault();
+    if (this.currentScale !== 1) {
+      event.stopPropagation();
+    }
+    if (this.isTwoFingerControl) {
+      this.handleScaleEnd();
+    }
+    this.isTwoFingerControl = false;
+    this.isOneFingerControl = false;
+  }
+  getDistance(touchTargetA, touchTargetB) {
+    return Math.sqrt(
+      Math.pow(touchTargetA.pageX - touchTargetB.pageX, 2) + Math.pow(touchTargetA.pageY - touchTargetB.pageY, 2)
+    );
+  }
+  getCenterPointer(touchTargetA, touchTargetB) {
+    return {
+      x: (touchTargetA.pageX + touchTargetB.pageX) / 2,
+      y: (touchTargetA.pageY + touchTargetB.pageY) / 2
+    };
+  }
+  getTranslateLimitedObj(translateObj, scale) {
+    const translateResult = { ...translateObj };
+    if (translateObj.x > 0) {
+      translateResult.x = 0;
+    }
+    if (translateObj.x < 0 - (scale - 1) * this.transformDom.offsetWidth) {
+      translateResult.x = 0 - (scale - 1) * this.transformDom.offsetWidth;
+    }
+    if (translateObj.y > 0) {
+      translateResult.y = 0;
+    }
+    if (translateObj.y < 0 - (scale - 1) * this.transformDom.offsetHeight) {
+      translateResult.y = 0 - (scale - 1) * this.transformDom.offsetHeight;
+    }
+    return translateResult;
+  }
+  handleScaleStart(event) {
+    const [initATarget, initBTarget] = event.touches;
+    this.lastDistance = this.getDistance(initATarget, initBTarget);
+    this.lastCenterPosition = this.getCenterPointer(initATarget, initBTarget);
+  }
+  handleScaleMove(event) {
+    const [moveATarget, moveBTarget] = event.touches;
+    const moveDistance = this.getDistance(moveATarget, moveBTarget);
+    const centerPosition = this.getCenterPointer(moveATarget, moveBTarget);
+    this.tempScale = this.currentScale * (moveDistance / this.lastDistance);
+    if (this.tempScale <= 1) {
+      this.tempTranslate = { x: 0, y: 0 };
+      this.tempScale = 1;
+    } else {
+      const gapTop = moveDistance / this.lastDistance * (this.currentScale * this.lastCenterPosition.y) - this.currentScale * centerPosition.y;
+      const gapLeft = moveDistance / this.lastDistance * (this.currentScale * this.lastCenterPosition.x) - this.currentScale * centerPosition.x;
+      this.tempTranslate = {
+        x: this.currentTranslate.x - gapLeft,
+        y: this.currentTranslate.y - gapTop
+      };
+      this.tempTranslate = this.getTranslateLimitedObj(
+        this.tempTranslate,
+        this.tempScale
+      );
+    }
+    this.transformDom.style.transform = `translate(${this.tempTranslate.x}px, ${this.tempTranslate.y}px) scale(${this.tempScale})`;
+  }
+  handleScaleEnd() {
+    this.currentScale = this.tempScale;
+    this.currentTranslate = this.tempTranslate;
+  }
+  handlePositionStart(event) {
+    this.lastPosition = {
+      x: event.touches[0].pageX,
+      y: event.touches[0].pageY
+    };
+  }
+  handlePositionMove(event) {
+    const currentPosition = {
+      x: event.touches[0].pageX,
+      y: event.touches[0].pageY
+    };
+    this.currentTranslate = {
+      x: this.currentTranslate.x + (currentPosition.x - this.lastPosition.x),
+      y: this.currentTranslate.y + (currentPosition.y - this.lastPosition.y)
+    };
+    this.currentTranslate = this.getTranslateLimitedObj(
+      this.currentTranslate,
+      this.currentScale
+    );
+    this.lastPosition = currentPosition;
+    this.transformDom.style.transform = `translate(${this.currentTranslate.x}px, ${this.currentTranslate.y}px) scale(${this.currentScale})`;
+  }
+}
+const vDblTouch = {
+  mounted(el, binding) {
+    if (binding.value) {
+      const newTouchScale = new TouchScale(el, binding);
+      touchScaleElementMap.set(el, newTouchScale);
+    }
+  },
+  updated(el, binding) {
+    var _a;
+    if (touchScaleElementMap.get(el)) {
+      (_a = touchScaleElementMap.get(el)) == null ? void 0 : _a.updateBinding(binding);
+    } else if (binding.value) {
+      const newTouchScale = new TouchScale(el, binding);
+      touchScaleElementMap.set(el, newTouchScale);
+    }
+  },
+  beforeUnmount(el) {
+    var _a;
+    (_a = touchScaleElementMap.get(el)) == null ? void 0 : _a.destroy();
+    touchScaleElementMap.delete(el);
+  }
+};
+export {
+  vDblTouch as default
+};

package/dist/handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './translator';
+export * from './voiceConverter';

package/dist/handler/index.js

@@ -0,0 +1,6 @@
+import { translator } from "./translator.js";
+import { voiceConverter } from "./voiceConverter.js";
+export {
+  translator,
+  voiceConverter
+};

package/dist/handler/translator.d.ts

@@ -0,0 +1,27 @@
+import { ITranslationTextType } from '../types/message';
+
+declare class Translator {
+    static instance: Translator | undefined;
+    private translationCache;
+    constructor();
+    get(messageID: string): Promise<ITranslationTextType[]>;
+    private getTranslationStandard;
+    /**
+     * the nick list is used to split the text by @ + {nick or userID}
+     * @param message
+     * @returns e.g. ['@james', '@john']
+     */
+    private getNickList;
+    /**
+     * Splits the given text into substrings based on the provided splitString array.
+     *
+     * @param {string} text - The text to be split.
+     * @param {string[]} splitString - The array of strings to split the text by.
+     * @return {{ transSplittingList: string[]; atNickList: string[] }} - An object containing two arrays:
+     *   - transSplittingList: An array of substrings extracted from the text.
+     *   - atNickList: An array of split strings that were found in the text.
+     */
+    private getSplitResult;
+}
+export declare const translator: Translator;
+export {};