@tencentcloud/roomkit-electron-vue3 2.3.3

package/src/TUIRoom/utils/utils.ts

@@ -0,0 +1,148 @@
+
+
+/**
+ * debounce function
+ * @param {*} fn Functions to execute
+ * @param {*} delay Interval time
+ * @returns function
+ */
+export function debounce(fn: { apply: (arg0: any, arg1: any) => void; }, delay: number | undefined) {
+  let timer: number;
+  return function (this:any, ...args: any) {
+    if (timer > 0) {
+      clearTimeout(timer);
+    }
+    timer = window?.setTimeout(() => {
+      fn.apply(this, args);
+      timer = -1;
+    }, delay);
+  };
+}
+
+/**
+ * throttle function
+ * @param {*} fn Functions to execute
+ * @param {*} delay Interval time
+ * @returns function
+ */
+export function throttle(fn: { apply: (arg0: any, arg1: any[]) => void; }, delay: number) {
+  let previousTime = 0;
+  return function (this:any, ...args: any[]) {
+    // eslint-disable-next-line prefer-rest-params
+    const now  = Date.now();
+    if (now - previousTime > delay) {
+      fn.apply(this, args);
+      previousTime = now;
+    }
+  };
+};
+
+/**
+ * Make the dom element fullscreen
+ * @param {dom} element dom element
+ * @example
+ * setFullscreen(document.documentElement) // The entire page goes full screen
+ * setFullscreen(document.getElementById("id")) // An element goes full screen
+ */
+export function setFullScreen(element: HTMLElement) {
+  const fullScreenElement = element as HTMLElement & {
+    mozRequestFullScreen(): Promise<void>;
+    msRequestFullscreen(): Promise<void>;
+    webkitRequestFullScreen(): Promise<void>;
+  };
+  if (fullScreenElement?.requestFullscreen) {
+    fullScreenElement?.requestFullscreen();
+  } else if (fullScreenElement?.mozRequestFullScreen) {
+    fullScreenElement?.mozRequestFullScreen();
+  } else if (fullScreenElement?.webkitRequestFullScreen) {
+    fullScreenElement?.webkitRequestFullScreen();
+  } else if (fullScreenElement?.msRequestFullscreen) {
+    fullScreenElement?.msRequestFullscreen();
+  }
+}
+
+/**
+ * exitFullscreen
+ * @example
+ * exitFullscreen();
+ */
+export function exitFullScreen() {
+  if (!document?.fullscreenElement
+    && !(document as any)?.webkitFullscreenElement && !(document as any)?.mozFullScreenElement) {
+    return;
+  }
+  const exitFullScreenDocument  = document as Document & {
+    mozCancelFullScreen(): Promise<void>;
+    msExitFullscreen(): Promise<void>;
+    webkitExitFullscreen(): Promise<void>;
+  };
+  if (exitFullScreenDocument?.exitFullscreen) {
+    exitFullScreenDocument?.exitFullscreen();
+  } else if (exitFullScreenDocument?.msExitFullscreen) {
+    exitFullScreenDocument?.msExitFullscreen();
+  } else if (exitFullScreenDocument?.mozCancelFullScreen) {
+    exitFullScreenDocument?.mozCancelFullScreen();
+  } else if (exitFullScreenDocument?.webkitExitFullscreen) {
+    exitFullScreenDocument?.webkitExitFullscreen();
+  }
+}
+
+
+/**
+ * Get the value of the specified key from window.location.href
+ * @param {*} key The key to get
+ * @returns The value corresponding to the key specified in window.location.href.
+ * @example
+ * const value = getUrlParam(key);
+ */
+export function getUrlParam(key: string) {
+  const url = window?.location.href.replace(/^[^?]*\?/, '');
+  const regexp = new RegExp(`(^|&)${key}=([^&#]*)(&|$|)`, 'i');
+  const paramMatch = url?.match(regexp);
+
+  return paramMatch ? paramMatch[2] : null;
+}
+
+
+/**
+ * deepClone
+ * @param data Raw data of any type
+ * @returns Data after deepClone
+ */
+export function deepClone(data: any) {
+  let res: any = null;
+  const reference = [Date, RegExp, Set, WeakSet, Map, WeakMap, Error];
+  if (reference.includes(data?.constructor)) {
+    res = new data.constructor(data);
+  } else if (Array.isArray(data)) {
+    res = [];
+    data.forEach((e, i) => {
+      res[i] = deepClone(e);
+    });
+  } else if (typeof data === 'object' && data !== null) {
+    res = {};
+    Object.keys(data).forEach((key) => {
+      if (Object.hasOwnProperty.call(data, key)) {
+        res[key] = deepClone(data[key]);
+      }
+    });
+  } else {
+    res = data;
+  }
+  return res;
+}
+
+export { clipBoard } from './adapter';
+
+export const isUndefined = (value: any) => typeof value === 'undefined';
+export const isString = (value: any) => typeof value === 'string';
+export const isNumber = (value: any) => typeof value === 'number';
+export const isStringNumber = (value: any) => typeof value === 'string' && !isNaN(Number(value));
+export const isFunction = (value: any) => typeof value === 'function';
+
+export function addSuffix(value: string | number, suffix = 'px') {
+  if (isNumber(value) || isStringNumber(value)) {
+    return value + suffix;
+  }
+  return value;
+}

package/src/TUIRoom/utils/vue.ts

@@ -0,0 +1,22 @@
+import * as Vue from 'vue';
+
+export default Vue;
+
+export function set(target: any, key: any, val: any) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1, val);
+    return val;
+  }
+  // eslint-disable-next-line no-param-reassign
+  target[key] = val;
+  return val;
+}
+
+export function del(target: any, key: any) {
+  if (Array.isArray(target) && typeof key === 'number') {
+    target.splice(key, 1);
+    return;
+  }
+  // eslint-disable-next-line no-param-reassign
+  delete target[key];
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,55 @@
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import dts from 'vite-plugin-dts';
+import cssInjectedByJsPlugin from 'vite-plugin-css-injected-by-js';
+import { dependencies, peerDependencies } from './package.json';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  build: {
+    // compressed
+    minify: false,
+    rollupOptions: {
+      external: [...Object.keys(dependencies), ...Object.keys(peerDependencies)],
+      input: ['src/TUIRoom/index.ts'],
+      output: [
+        {
+          format: 'es',
+          entryFileNames: '[name].mjs',
+          preserveModules: true,
+          preserveModulesRoot: 'src/TUIRoom',
+          exports: 'named',
+          dir: 'es',
+          globals: {
+            vue: 'Vue',
+            pinia: 'pinia',
+          },
+        },
+        {
+          format: 'cjs',
+          entryFileNames: '[name].js',
+          preserveModules: true,
+          preserveModulesRoot: 'src/TUIRoom',
+          exports: 'named',
+          dir: 'lib',
+          globals: {
+            vue: 'Vue',
+            pinia: 'pinia',
+          },
+        },
+      ],
+    },
+    lib: {
+      entry: './src/TUIRoom/index.ts',
+      name: 'TUIRoomKit',
+    },
+  },
+  plugins: [
+    vue(),
+    cssInjectedByJsPlugin(),
+    dts({
+      entryRoot: './src/TUIRoom',
+      outDir: ['lib/', 'es/'],
+    }),
+  ],
+});