tuikit-atomicx-vue3 0.1.0

package/src/utils/environment.ts

@@ -0,0 +1,24 @@
+import { getPlatform } from '@tencentcloud/universal-api';
+
+declare const uni: any;
+
+export const isPC = getPlatform() === 'pc';
+
+export const isH5 = getPlatform() === 'h5';
+
+export const isWeChat = getPlatform() === 'wechat';
+
+export const isApp = getPlatform() === 'app';
+
+export const isUniFrameWork = typeof uni !== 'undefined';
+
+// H5, small programs, apps are considered mobile products, if you need to unify the mobile UI style, you can directly use isMobile to control
+export const isMobile = isH5 || isWeChat || isApp;
+
+export const isElectron =
+  navigator.userAgent?.toLowerCase().indexOf(' electron/') > -1;
+
+// WeiXinBrowser
+export const isWeiXinBrowser =
+  navigator &&
+  navigator.userAgent?.toLocaleLowerCase().indexOf('micromessenger') > -1;

package/src/utils/index.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/src/utils/json.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 });
+ */
+function safeJSONParse<T>(
+  text: string,
+  defaultValue: T,
+  reviver?: (key: string, value: any) => any,
+): T {
+  if (!text) {
+    return defaultValue;
+  }
+
+  try {
+    // resolve some usual errors
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return defaultValue;
+    }
+    if (trimmed === 'undefined') {
+      return defaultValue;
+    }
+    if (trimmed === 'null') {
+      return null as T;
+    }
+
+    const parsed = JSON.parse(trimmed, reviver);
+
+    // verify parsed value
+    if (parsed === undefined || parsed === null) {
+      return defaultValue;
+    }
+
+    return parsed;
+  } catch (error) {
+    console.warn('JSON parse failed:', error);
+    return defaultValue;
+  }
+}
+
+export {
+  safeJSONParse,
+};

package/src/utils/lodash.ts

@@ -0,0 +1,169 @@
+/* eslint-disable */
+// @ts-nocheck
+/** Error message constants. */
+const FUNC_ERROR_TEXT = 'Expected a function';
+
+interface IDebounceOptions {
+  leading?: boolean;
+  maxWait?: number;
+  trailing?: boolean;
+}
+
+type IThrottleOptions = IDebounceOptions;
+
+function throttle(func, wait: number, options?: IThrottleOptions) {
+  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: leading,
+    maxWait: wait,
+    trailing: trailing,
+  });
+}
+
+function debounce(func, wait: number, options?: IDebounceOptions) {
+  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 = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function leadingEdge(time) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = setTimeout(timerExpired, wait);
+    // Invoke the leading edge.
+    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;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (lastCallTime === undefined || (timeSinceLastCall >= wait)
+      || (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+  }
+
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(Date.now());
+  }
+
+  function debounced() {
+    const time = Date.now(),
+      isInvoking = shouldInvoke(time);
+
+    // eslint-disable-next-line prefer-rest-params
+    lastArgs = arguments;
+
+    // @ts-expect-error ignore this type
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      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/src/utils/riseInput.ts

@@ -0,0 +1,53 @@
+import { isIOS } from '@tencentcloud/universal-api';
+const ua = navigator.userAgent;
+
+function getScrollTypeByPlatform() {
+  if (isIOS) {
+    if (/Safari\//.test(ua) || /IOS 11_[0-3]\D/.test(ua)) {
+      // Safari IOS 11.0-11.3 exclude（`scrollTop`/`scrolIntoView` not working）
+      return 0;
+    }
+    // IOS: use `scrollTop`
+    return 1;
+  }
+  // Android: use `scrollIntoView`
+  return 2;
+}
+
+export default function riseInput(input: HTMLElement, target?: HTMLElement) {
+  const scrollType = getScrollTypeByPlatform();
+  let scrollTimer: ReturnType<typeof setTimeout>;
+
+  if (!target) {
+    // eslint-disable-next-line no-param-reassign
+    target = input;
+  }
+
+  const scrollIntoView = () => {
+    if (scrollType === 0) return;
+    if (scrollType === 1) {
+      document.body.scrollTop = document.body.scrollHeight;
+    } else {
+      target?.scrollIntoView(false);
+    }
+  };
+
+  input.addEventListener('focus', () => {
+    const timer = setTimeout(() => {
+      scrollIntoView();
+      clearTimeout(timer);
+    }, 300);
+    scrollTimer = setTimeout(scrollIntoView, 1000);
+  });
+
+  input.addEventListener('blur', () => {
+    clearTimeout(scrollTimer);
+    // Handle IOS issues about keyboard is hidden but page not refreshed
+    if (scrollType && isIOS) {
+      const timer = setTimeout(() => {
+        document.body.scrollIntoView();
+        clearTimeout(timer);
+      });
+    }
+  });
+}

package/src/utils/time.ts

@@ -0,0 +1,87 @@
+import { useUIKit, i18next } from '@tencentcloud/uikit-base-component-vue3';
+import {
+  format,
+  isSameWeek,
+  isThisYear,
+  isToday,
+  isYesterday,
+} from 'date-fns';
+import { zhCN, ja, ko, zhTW, enUS } from 'date-fns/locale';
+
+interface IGetTimeStampOptions {
+  time: number;
+  language?: 'zh-CN' | 'zh-TW' | 'en-US' | 'ja-JP' | 'ko-KR' | string;
+}
+
+function getTimeStamp({ time, language = 'en-US' }: IGetTimeStampOptions) {
+  const locales: Record<string, any> = {
+    'zh-CN': zhCN,
+    'zh-TW': zhTW,
+    'en-US': enUS,
+    'ja-JP': ja,
+    'ko-KR': ko,
+  };
+  const timeFormat = 'HH:mm';
+  const locale = locales[language] || locales['en-US'];
+  const { t } = useUIKit();
+
+  const yesterdayText = t('TUIChat.Yesterday', {
+    defaultValue: 'Yesterday',
+  });
+
+  if (!time) {
+    return '';
+  }
+
+  if (isToday(time)) {
+    return format(time, timeFormat, {
+      locale,
+    });
+  }
+
+  if (isYesterday(time)) {
+    return `${yesterdayText} ${format(time, timeFormat, {
+      locale,
+    })}`;
+  }
+
+  if (isSameWeek(time, new Date(), { weekStartsOn: 1 })) {
+    return `${format(time, 'EEEE', { locale })} ${format(time, timeFormat)}`;
+  }
+
+  if (isThisYear(time)) {
+    if (language.startsWith('zh')) {
+      return format(time, 'M月d日 HH:mm', {
+        locale,
+      });
+    }
+    return format(time, 'MMMM d HH:mm', {
+      locale,
+    });
+  }
+
+  return format(time, 'yyyy/MM/dd HH:mm', {
+    locale,
+  });
+}
+
+/**
+ * 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
+ */
+function getTimeStampAuto(time: number) {
+  return getTimeStamp({ time, language: i18next.language });
+}
+
+export {
+  getTimeStamp,
+  getTimeStampAuto,
+};

package/src/utils/type-check.ts

@@ -0,0 +1,44 @@
+const objectToString = Object.prototype.toString;
+const toTypeString = (value: any) => objectToString.call(value);
+
+export const { isArray } = Array;
+export const isMap = (val: any) => toTypeString(val) === '[object Map]';
+export const isSet = (val: any) => toTypeString(val) === '[object Set]';
+export const isDate = (val: any) => val instanceof Date;
+export const isFunction = (val: any) => typeof val === 'function';
+export const isString = (val: any) => typeof val === 'string';
+export const isSymbol = (val: any) => typeof val === 'symbol';
+export const isObject = (val: any) => val !== null && typeof val === 'object';
+export const isPromise = (val: any) =>
+  isObject(val) && isFunction(val.then) && isFunction(val.catch);
+// Determine whether it is url
+export const isUrl = (url: string) => {
+  return /^(https?:\/\/(([a-zA-Z0-9]+-?)+[a-zA-Z0-9]+\.)+[a-zA-Z]+)(:\d+)?(\/.*)?(\?.*)?(#.*)?$/.test(
+    url,
+  );
+};
+
+// Determine if it is a JSON string
+export const isJSON = (str: string) => {
+  // eslint-disable-next-line no-useless-escape
+  if (typeof str === 'string') {
+    try {
+      const data = JSON.parse(str);
+      if (data) {
+        return true;
+      }
+      return false;
+    } catch (error: any) {
+      return false;
+    }
+  }
+  return false;
+};
+
+// Determine if it is a JSON string
+export const JSONToObject = (str: string) => {
+  if (!str || !isJSON(str)) {
+    return str;
+  }
+  return JSON.parse(str);
+};