tuikit-atomicx-vue3 0.1.0

package/dist/utils/domOperation.d.ts

@@ -0,0 +1,45 @@
+interface IDomRect {
+    id: string;
+    top: number;
+    left: number;
+    right: number;
+    width: number;
+    bottom: number;
+    height: number;
+    x?: number;
+    y?: number;
+}
+interface IScrollInfo {
+    scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    id: string;
+}
+interface IFields {
+    [key: string]: any;
+}
+type registeredPage = 'messageList';
+export declare const instanceMapping: Map<"messageList", any>;
+/**
+ *
+ * @param selector string: e.g. #app | .class
+ * @param instanceName string
+ * @returns Promise<IDomRect>
+ */
+export declare function getBoundingClientRect(selector: string | HTMLElement, instanceName?: registeredPage): Promise<IDomRect>;
+export declare function getBoundingClientRectSync(selector: string | HTMLElement): IDomRect;
+/**
+ *
+ * @param selector string: e.g. #app | .class
+ * @param instanceName string
+ * @returns Promise<IScrollInfo>
+ */
+export declare function getScrollInfo(selector: string | HTMLElement, instanceName?: registeredPage): Promise<IScrollInfo>;
+export declare function getScrollInfoSync(selector: string | HTMLElement): IScrollInfo;
+export declare function getFields(selector: string | HTMLElement, instanceName?: registeredPage): Promise<IFields>;
+export declare function getContentSize(element: HTMLElement): {
+    width: number;
+    height: number;
+};
+export {};

package/dist/utils/domOperation.js

@@ -0,0 +1,183 @@
+import { isWeChat } from "./environment.js";
+const instanceMapping = /* @__PURE__ */ new Map();
+function getBoundingClientRect(selector, instanceName) {
+  if (!selector)
+    return Promise.reject(
+      new Error(
+        `getBoundingClientRect() get error selector ${typeof selector}.`
+      )
+    );
+  if (window || document) {
+    const dom = typeof selector === "object" ? selector : document.querySelector(selector);
+    if (!dom)
+      return Promise.reject(
+        new Error(`getBoundingClientRect() can't find ${selector} dom.`)
+      );
+    const domRect = dom.getBoundingClientRect();
+    return Promise.resolve({
+      id: dom.id,
+      top: domRect.top,
+      left: domRect.left,
+      right: domRect.right,
+      bottom: domRect.bottom,
+      width: domRect.width,
+      height: domRect.height,
+      x: domRect.x,
+      y: domRect.y
+    });
+  }
+  if (isWeChat) {
+    if (!instanceName)
+      return Promise.reject(
+        new Error("uni.getBoundingClientRect() need instanceName in params.")
+      );
+    const _query = uni.createSelectorQuery().in(instanceMapping.get(instanceName));
+    return new Promise((resolve, reject) => {
+      _query.select(selector).boundingClientRect((data) => {
+        if (data) {
+          resolve(data);
+        }
+      }).exec();
+      setTimeout(
+        () => reject(new Error(`uni.getBoundingClientRect(${selector}) timeout.`)),
+        500
+      );
+    });
+  }
+  return Promise.reject(new Error("getBoundingClientRect() occur error"));
+}
+function getBoundingClientRectSync(selector) {
+  if (isWeChat) {
+    throw new Error("getBoundingClientRectSync() can not use in uni-app.");
+  }
+  if (window || document) {
+    const dom = typeof selector === "object" ? selector : document.querySelector(selector);
+    if (!dom)
+      throw new Error(
+        `getBoundingClientRectSync() can't find ${selector} dom.`
+      );
+    const domRect = dom.getBoundingClientRect();
+    return {
+      id: dom.id,
+      top: domRect.top,
+      left: domRect.left,
+      right: domRect.right,
+      bottom: domRect.bottom,
+      width: domRect.width,
+      height: domRect.height,
+      x: domRect.x,
+      y: domRect.y
+    };
+  }
+  throw new Error("getBoundingClientRectSync() occur error.");
+}
+function getScrollInfo(selector, instanceName) {
+  if (!selector)
+    return Promise.reject(
+      new Error(`getScrollInfo() get error selector ${typeof selector}.`)
+    );
+  if (!isWeChat && window) {
+    const dom = typeof selector === "object" ? selector : document.querySelector(selector);
+    if (!dom)
+      return Promise.reject(
+        new Error(`getScrollInfo() can't find ${selector} dom.`)
+      );
+    return Promise.resolve({
+      id: dom.id,
+      scrollTop: dom.scrollTop,
+      scrollLeft: dom.scrollLeft,
+      scrollWidth: dom.scrollWidth,
+      scrollHeight: dom.scrollHeight
+    });
+  }
+  if (isWeChat) {
+    if (!instanceName)
+      return Promise.reject(
+        new Error("uni.getScrollInfo() need instanceName in params.")
+      );
+    const _query = uni.createSelectorQuery().in(instanceMapping.get(instanceName));
+    return new Promise((resolve, reject) => {
+      _query.select(selector).scrollOffset((data) => {
+        if (data) {
+          resolve(data);
+        }
+      }).exec();
+      setTimeout(
+        () => reject(new Error(`uni.getScrollInfo(${selector}) timeout.`)),
+        500
+      );
+    });
+  }
+  return Promise.reject(new Error("getScrollInfo() occur error"));
+}
+function getScrollInfoSync(selector) {
+  if (isWeChat) {
+    throw new Error("getScrollInfoSync() can not use in uni-app.");
+  }
+  if (!isWeChat && window) {
+    const dom = typeof selector === "object" ? selector : document.querySelector(selector);
+    if (!dom)
+      throw new Error(`getScrollInfoSync() can't find ${selector} dom.`);
+    return {
+      id: dom.id,
+      scrollTop: dom.scrollTop,
+      scrollLeft: dom.scrollLeft,
+      scrollWidth: dom.scrollWidth,
+      scrollHeight: dom.scrollHeight
+    };
+  }
+  throw new Error("getScrollInfoSync() occur error.");
+}
+function getFields(selector, instanceName) {
+  if (isWeChat) {
+    if (!instanceName)
+      return Promise.reject(
+        new Error("uni.getFields() need instanceName in params.")
+      );
+    const _query = uni.createSelectorQuery().in(instanceMapping.get(instanceName));
+    return new Promise((resolve, reject) => {
+      _query.select(selector).fields(
+        {
+          rect: true,
+          size: true,
+          scrollOffset: true
+        },
+        (data) => {
+          if (data) {
+            resolve(data);
+          }
+        }
+      ).exec();
+      setTimeout(
+        () => reject(new Error(`get ${selector} fields timeout.`)),
+        500
+      );
+    });
+  }
+  return Promise.reject(new Error("getFields() occur error"));
+}
+function getContentSize(element) {
+  const computedStyle = getComputedStyle(element);
+  const paddingTop = Number(computedStyle.paddingTop.replace("px", ""));
+  const paddingBottom = Number(computedStyle.paddingBottom.replace("px", ""));
+  const borderTop = Number(computedStyle.borderTopWidth.replace("px", ""));
+  const borderBottom = Number(
+    computedStyle.borderBottomWidth.replace("px", "")
+  );
+  const paddingLeft = Number(computedStyle.paddingLeft.replace("px", ""));
+  const paddingRight = Number(computedStyle.paddingRight.replace("px", ""));
+  const borderLeft = Number(computedStyle.borderLeftWidth.replace("px", ""));
+  const borderRight = Number(computedStyle.borderRightWidth.replace("px", ""));
+  const contentWidth = element.offsetWidth - paddingLeft - paddingRight - borderLeft - borderRight;
+  const contentHeight = element.offsetHeight - paddingTop - paddingBottom - borderTop - borderBottom;
+  return { width: contentWidth, height: contentHeight };
+}
+export {
+  getBoundingClientRect,
+  getBoundingClientRectSync,
+  getContentSize,
+  getFields,
+  getScrollInfo,
+  getScrollInfoSync,
+  instanceMapping
+};

package/dist/utils/downFile.d.ts

@@ -0,0 +1,2 @@
+declare function downFile(url: string, fileName?: string): void;
+export { downFile, };

package/dist/utils/downFile.js

@@ -0,0 +1,27 @@
+function downFile(url, fileName) {
+  const options = {
+    mode: "cors",
+    headers: new Headers({ "Content-Type": "application/x-www-form-urlencoded" })
+  };
+  let _fileName = fileName;
+  if (!fileName) {
+    _fileName = Math.random().toString(36).substring(7);
+  }
+  if (typeof window.fetch === "function") {
+    fetch(url, options).then((res) => res.blob()).then((blob) => {
+      const a = document.createElement("a");
+      const url2 = window.URL.createObjectURL(blob);
+      a.href = url2;
+      a.download = _fileName || "file";
+      a.click();
+    });
+  } else {
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = _fileName || "file";
+    a.click();
+  }
+}
+export {
+  downFile
+};

package/dist/utils/emoji.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Transforms a text containing emoji keys to a emoji names with i18n
+ * Example:
+ * 'hello[TUIEmoji_Smile]!' => 'hello[Smile]!''
+ * @param {string} text - The text containing emoji keys.
+ * @return {string} The transformed text with emoji keys replaced by emoji names.
+ */
+export declare function transformTextWithEmojiKeyToName(text: string): string;
+/**
+ * Transforms a text containing emoji names to emoji keys with i18n
+ * Example:
+ * 'hello[Smile]!' => 'hello[TUIEmoji_Smile]!'
+ * @param {string} text - The text containing emoji names.
+ * @return {string} The transformed text with emoji names replaced by emoji keys.
+ */
+export declare function transformTextWithEmojiNameToKey(text: string): string;

package/dist/utils/emoji.js

@@ -0,0 +1,40 @@
+import { i18next } from "@tencentcloud/uikit-base-component-vue3";
+import { emojiUrlMap } from "../constants/emoji.js";
+function transformTextWithEmojiKeyToName(text) {
+  if (!text) {
+    return "";
+  }
+  const reg = /(\[.+?\])/g;
+  let transformResult = text;
+  if (reg.test(text)) {
+    transformResult = text.replace(reg, (match) => emojiUrlMap[match] ? i18next.t(`Emoji.${match}`) : match);
+  }
+  return transformResult;
+}
+const emojiTranslationMap = {};
+function transformTextWithEmojiNameToKey(text) {
+  var _a;
+  if (!text) {
+    return "";
+  }
+  const reg = /(\[.+?\])/g;
+  let transformResult = text;
+  if (reg.test(text)) {
+    const currentLanguage = i18next.language;
+    if (!emojiTranslationMap[currentLanguage]) {
+      const lngResource = i18next.getDataByLanguage(currentLanguage);
+      if ((_a = lngResource == null ? void 0 : lngResource.translation) == null ? void 0 : _a.Emoji) {
+        emojiTranslationMap[currentLanguage] = Object.fromEntries(Object.entries(lngResource.translation.Emoji).map(([key, value]) => [value, key]));
+      }
+    }
+    transformResult = text.replace(reg, (match) => {
+      var _a2;
+      return ((_a2 = emojiTranslationMap[currentLanguage]) == null ? void 0 : _a2.match) ?? match;
+    });
+  }
+  return transformResult;
+}
+export {
+  transformTextWithEmojiKeyToName,
+  transformTextWithEmojiNameToKey
+};

package/dist/utils/enableSampleTaskStatus.d.ts

@@ -0,0 +1 @@
+export declare function enableSampleTaskStatus(taskKey: string): void;

package/dist/utils/enableSampleTaskStatus.js

@@ -0,0 +1,11 @@
+import { TUIStore, StoreName } from "@tencentcloud/chat-uikit-engine";
+function enableSampleTaskStatus(taskKey) {
+  const tasks = TUIStore.getData(StoreName.APP, "tasks");
+  if (taskKey in tasks && !tasks[taskKey]) {
+    tasks[taskKey] = true;
+    TUIStore.update(StoreName.APP, "tasks", tasks);
+  }
+}
+export {
+  enableSampleTaskStatus
+};

package/dist/utils/env.d.ts

@@ -0,0 +1,6 @@
+export declare const isPC: boolean;
+export declare const isH5: boolean;
+export declare const isWeChat: boolean;
+export declare const isApp: boolean;
+export declare const isUniFrameWork: boolean;
+export declare const isMobile: boolean;

package/dist/utils/env.js

@@ -0,0 +1,15 @@
+import { g } from "../index-BREVQgBq.js";
+const isPC = g() === "pc";
+const isH5 = g() === "h5";
+const isWeChat = g() === "wechat";
+const isApp = g() === "app";
+const isUniFrameWork = typeof uni !== "undefined";
+const isMobile = isH5 || isWeChat || isApp;
+export {
+  isApp,
+  isH5,
+  isMobile,
+  isPC,
+  isUniFrameWork,
+  isWeChat
+};

package/dist/utils/environment.d.ts

@@ -0,0 +1,8 @@
+export declare const isPC: boolean;
+export declare const isH5: boolean;
+export declare const isWeChat: boolean;
+export declare const isApp: boolean;
+export declare const isUniFrameWork: boolean;
+export declare const isMobile: boolean;
+export declare const isElectron: boolean;
+export declare const isWeiXinBrowser: boolean;

package/dist/utils/environment.js

@@ -0,0 +1,20 @@
+var _a, _b;
+import { g } from "../index-BREVQgBq.js";
+const isPC = g() === "pc";
+const isH5 = g() === "h5";
+const isWeChat = g() === "wechat";
+const isApp = g() === "app";
+const isUniFrameWork = typeof uni !== "undefined";
+const isMobile = isH5 || isWeChat || isApp;
+const isElectron = ((_a = navigator.userAgent) == null ? void 0 : _a.toLowerCase().indexOf(" electron/")) > -1;
+const isWeiXinBrowser = navigator && ((_b = navigator.userAgent) == null ? void 0 : _b.toLocaleLowerCase().indexOf("micromessenger")) > -1;
+export {
+  isApp,
+  isElectron,
+  isH5,
+  isMobile,
+  isPC,
+  isUniFrameWork,
+  isWeChat,
+  isWeiXinBrowser
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './type-check';
+export * from './lodash';
+export * from './env';
+export * from './downFile';
+export * from './copyText';
+export * from './emoji';
+export * from './json';

package/dist/utils/index.js

@@ -0,0 +1,34 @@
+import { JSONToObject, isArray, isDate, isFunction, isJSON, isMap, isObject, isPromise, isSet, isString, isSymbol, isUrl } from "./type-check.js";
+import { debounce, throttle } from "./lodash.js";
+import { isApp, isH5, isMobile, isPC, isUniFrameWork, isWeChat } from "./env.js";
+import { downFile } from "./downFile.js";
+import { copyTextToClipboard } from "./copyText.js";
+import { transformTextWithEmojiKeyToName, transformTextWithEmojiNameToKey } from "./emoji.js";
+import { safeJSONParse } from "./json.js";
+export {
+  JSONToObject,
+  copyTextToClipboard,
+  debounce,
+  downFile,
+  isApp,
+  isArray,
+  isDate,
+  isFunction,
+  isH5,
+  isJSON,
+  isMap,
+  isMobile,
+  isObject,
+  isPC,
+  isPromise,
+  isSet,
+  isString,
+  isSymbol,
+  isUniFrameWork,
+  isUrl,
+  isWeChat,
+  safeJSONParse,
+  throttle,
+  transformTextWithEmojiKeyToName,
+  transformTextWithEmojiNameToKey
+};

package/dist/utils/json.d.ts

@@ -0,0 +1,13 @@
+/**
+ * safe JSON parse function
+ * @param text JSON string
+ * @param defaultValue default value when parse failed
+ * @param reviver JSON.parse reviver function
+ * demo:
+ * const data = safeJSONParse('{"name": "test"}', {});
+ * const array = safeJSONParse('[1,2,3]', []);
+ * const num = safeJSONParse('123', 0);
+ * const invalidJson = safeJSONParse('invalid json', { fallback: true });
+ */
+declare function safeJSONParse<T>(text: string, defaultValue: T, reviver?: (key: string, value: any) => any): T;
+export { safeJSONParse, };

package/dist/utils/json.js

@@ -0,0 +1,28 @@
+function safeJSONParse(text, defaultValue, reviver) {
+  if (!text) {
+    return defaultValue;
+  }
+  try {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return defaultValue;
+    }
+    if (trimmed === "undefined") {
+      return defaultValue;
+    }
+    if (trimmed === "null") {
+      return null;
+    }
+    const parsed = JSON.parse(trimmed, reviver);
+    if (parsed === void 0 || parsed === null) {
+      return defaultValue;
+    }
+    return parsed;
+  } catch (error) {
+    console.warn("JSON parse failed:", error);
+    return defaultValue;
+  }
+}
+export {
+  safeJSONParse
+};

package/dist/utils/lodash.d.ts

@@ -0,0 +1,17 @@
+interface IDebounceOptions {
+    leading?: boolean;
+    maxWait?: number;
+    trailing?: boolean;
+}
+type IThrottleOptions = IDebounceOptions;
+declare function throttle(func: any, wait: number, options?: IThrottleOptions): {
+    (): any;
+    cancel: () => void;
+    flush: () => any;
+};
+declare function debounce(func: any, wait: number, options?: IDebounceOptions): {
+    (): any;
+    cancel: () => void;
+    flush: () => any;
+};
+export { debounce, throttle, };

package/dist/utils/lodash.js

@@ -0,0 +1,105 @@
+const FUNC_ERROR_TEXT = "Expected a function";
+function throttle(func, wait, options) {
+  let leading = true, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  if (options && isObject(options)) {
+    leading = "leading" in options ? !!options.leading : leading;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  return debounce(func, wait, {
+    leading,
+    maxWait: wait,
+    trailing
+  });
+}
+function debounce(func, wait, options) {
+  let lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = wait || 0;
+  if (options && isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    const args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced() {
+    const time = Date.now(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isObject(value) {
+  const type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+export {
+  debounce,
+  throttle
+};

package/dist/utils/riseInput.d.ts

@@ -0,0 +1 @@
+export default function riseInput(input: HTMLElement, target?: HTMLElement): void;

package/dist/utils/riseInput.js

@@ -0,0 +1,45 @@
+import { f } from "../index-BREVQgBq.js";
+const ua = navigator.userAgent;
+function getScrollTypeByPlatform() {
+  if (f) {
+    if (/Safari\//.test(ua) || /IOS 11_[0-3]\D/.test(ua)) {
+      return 0;
+    }
+    return 1;
+  }
+  return 2;
+}
+function riseInput(input, target) {
+  const scrollType = getScrollTypeByPlatform();
+  let scrollTimer;
+  if (!target) {
+    target = input;
+  }
+  const scrollIntoView = () => {
+    if (scrollType === 0) return;
+    if (scrollType === 1) {
+      document.body.scrollTop = document.body.scrollHeight;
+    } else {
+      target == null ? void 0 : target.scrollIntoView(false);
+    }
+  };
+  input.addEventListener("focus", () => {
+    const timer = setTimeout(() => {
+      scrollIntoView();
+      clearTimeout(timer);
+    }, 300);
+    scrollTimer = setTimeout(scrollIntoView, 1e3);
+  });
+  input.addEventListener("blur", () => {
+    clearTimeout(scrollTimer);
+    if (scrollType && f) {
+      const timer = setTimeout(() => {
+        document.body.scrollIntoView();
+        clearTimeout(timer);
+      });
+    }
+  });
+}
+export {
+  riseInput as default
+};

package/dist/utils/time.d.ts

@@ -0,0 +1,19 @@
+interface IGetTimeStampOptions {
+    time: number;
+    language?: 'zh-CN' | 'zh-TW' | 'en-US' | 'ja-JP' | 'ko-KR' | string;
+}
+declare function getTimeStamp({ time, language }: IGetTimeStampOptions): string;
+/**
+ * Get formatted time string
+ * 1. If today, only show time (HH:mm)
+ * 2. If yesterday, show 'Yesterday' + time
+ * 3. If within current week, show weekday + time
+ * 4. If earlier than current week but within this year, show date format based on locale
+ * 5. Otherwise show full date + time
+ *
+ * @param time Timestamp in milliseconds
+ * @param language Language code, default is 'en-US'
+ * @returns Formatted time string
+ */
+declare function getTimeStampAuto(time: number): string;
+export { getTimeStamp, getTimeStampAuto, };