@unicom-cloud/ui 0.8.41

package/types/virtual-list/Filler.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface FillerProps {
+    height: number;
+    offset?: number;
+    outerStyle?: React.CSSProperties;
+    innerStyle?: React.CSSProperties;
+    children: React.ReactNode;
+}
+declare const Filler: React.FC<FillerProps>;
+export default Filler;

package/types/virtual-list/VirtualList.d.ts

@@ -0,0 +1,39 @@
+import { Options as ScrollIntoViewOptions } from '@unicom-cloud/scroll-into-view-if-needed';
+import React, { CSSProperties, ReactNode, UIEvent } from 'react';
+import { Key } from './util/item';
+export type RenderFunc<T> = (item: T, index: number, props: {
+    style: React.CSSProperties;
+    itemIndex: number;
+}) => ReactNode;
+export interface VirtualListProps<T> extends Omit<React.HTMLAttributes<any>, 'children' | 'onScroll'> {
+    children: RenderFunc<T>;
+    data: T[];
+    height?: number | string;
+    itemHeight?: number;
+    wrapper?: string | React.FC<any> | React.ComponentClass<any>;
+    threshold?: number | null;
+    isStaticItemHeight?: boolean;
+    itemKey?: Key | ((item: T, index: number) => Key);
+    measureLongestItem?: boolean;
+    scrollOptions?: ScrollIntoViewOptions;
+    needFiller?: boolean;
+    outerStyle?: CSSProperties;
+    innerStyle?: CSSProperties;
+    onScroll?: (event: UIEvent<HTMLElement>, info: {
+        index: number;
+    }) => void;
+    wrapperChild?: string | React.FC<any> | React.ComponentClass<any>;
+}
+export type AvailableVirtualListProps = Pick<VirtualListProps<any>, 'height' | 'itemHeight' | 'threshold' | 'isStaticItemHeight' | 'scrollOptions' | 'onScroll' | 'wrapperChild'>;
+export type VirtualListHandle = {
+    dom: HTMLElement;
+    scrollTo: (arg: number | {
+        index: number;
+        options?: ScrollIntoViewOptions;
+    } | {
+        key: Key;
+        options?: ScrollIntoViewOptions;
+    }) => void;
+};
+declare const VirtualList: React.ForwardRefExoticComponent<VirtualListProps<any> & React.RefAttributes<VirtualListHandle>>;
+export default VirtualList;

package/types/virtual-list/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import VirtualList from './VirtualList';
+export default VirtualList;
+export type { AvailableVirtualListProps, RenderFunc, VirtualListHandle, } from './VirtualList';

package/types/virtual-list/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/virtual-list/util/algorithm.d.ts

@@ -0,0 +1,6 @@
+import { Key } from './item';
+export declare function getIndexByStartLoc(min: number, max: number, start: number, index: number): number;
+export declare function findListDiffIndex<T>(originList: T[], targetList: T[], getKey: (item: T, index: number) => Key): {
+    index: number;
+    multiple: boolean;
+} | null;

package/types/virtual-list/util/item.d.ts

@@ -0,0 +1,44 @@
+export declare const GHOST_ITEM_KEY = "__rc_ghost_item__";
+export type Key = string | number;
+interface LocationItemResult {
+    index: number;
+    offsetPtg: number;
+}
+export declare function getLocationItem(scrollPtg: number, total: number): LocationItemResult;
+export declare function getNodeHeight(node: HTMLElement, needMargin?: boolean): number;
+export declare function getValidScrollTop(scrollTop: number, scrollRange: number): number;
+export declare function getScrollPercentage({ scrollTop, scrollHeight, clientHeight, }: {
+    scrollTop: number;
+    scrollHeight: number;
+    clientHeight: number;
+}): number;
+export declare function getRangeIndex(scrollPtg: number, itemCount: number, visibleCount: number): {
+    itemIndex: number;
+    itemOffsetPtg: number;
+    startIndex: number;
+    endIndex: number;
+};
+interface ItemTopConfig {
+    itemHeight: number;
+    itemOffsetPtg: number;
+    scrollTop: number;
+    scrollPtg: number;
+    clientHeight: number;
+}
+export declare function getItemRelativeTop({ itemHeight, itemOffsetPtg, scrollPtg, clientHeight, }: Omit<ItemTopConfig, 'scrollTop'>): number;
+export declare function getItemAbsoluteTop({ scrollTop, ...rest }: ItemTopConfig): number;
+interface CompareItemConfig {
+    locatedItemRelativeTop: number;
+    locatedItemIndex: number;
+    compareItemIndex: number;
+    getItemKey: (index: number) => Key;
+    startIndex: number;
+    endIndex: number;
+    itemElementHeights: {
+        [key: string]: number;
+    };
+    itemHeight: number;
+}
+export declare function getCompareItemRelativeTop({ locatedItemRelativeTop, locatedItemIndex, compareItemIndex, startIndex, endIndex, getItemKey, itemElementHeights, itemHeight, }: CompareItemConfig): number;
+export declare function getLongestItemIndex(data: Array<any>): number;
+export {};

package/types/watermark/Watermark.d.ts

@@ -0,0 +1,4 @@
+import { WatermarkProps } from './interface';
+export declare function WatermarkComponent(baseProps: WatermarkProps, _: any): import("react/jsx-dev-runtime").JSX.Element | null;
+declare const Watermark: import("react").ForwardRefExoticComponent<WatermarkProps & import("react").RefAttributes<unknown>>;
+export default Watermark;

package/types/watermark/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import { WatermarkProps } from './interface';
+import Watermark from './Watermark';
+export { type WatermarkProps };
+export default Watermark;

package/types/watermark/interface.d.ts

@@ -0,0 +1,21 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface WatermarkProps {
+    style?: CSSProperties;
+    className?: string;
+    zIndex?: string | number;
+    width?: number | string;
+    height?: number | string;
+    rotate?: number;
+    image?: string;
+    content?: string | string[];
+    fontStyle?: {
+        color?: string;
+        fontFamily?: string;
+        fontSize?: number | string;
+        fontWeight?: number | string;
+    };
+    gap?: [number, number];
+    offset?: [number, number];
+    getContainer?: () => HTMLElement;
+    children?: ReactNode;
+}

package/types/watermark/style/index.d.ts

@@ -0,0 +1 @@
+import './index.less';

package/utils/className.js

@@ -0,0 +1,5 @@
+import "@unicom-cloud/utils/class-name";
+import { default as e } from "@unicom-cloud/utils/class-name";
+export {
+  e as default
+};

package/utils/constant.js

@@ -0,0 +1,23 @@
+import n from "./pick.js";
+const e = () => {
+};
+function t(o) {
+  return Array.apply(null, Array(o));
+}
+function u(o) {
+  return n(o, [
+    "onMouseEnter",
+    "onMouseLeave",
+    "onMouseMove",
+    "onContextMenu",
+    "onClick",
+    "onFocus",
+    "onBlur",
+    "tabIndex"
+  ]);
+}
+export {
+  e as NOOP,
+  t as newArray,
+  u as pickTriggerPropsFromRest
+};

package/utils/contextHolder.js

@@ -0,0 +1,6 @@
+import "react";
+import "../chunk/DP2rzg_V.js";
+import { e as m } from "../chunk/Dc_89PVN.js";
+export {
+  m as default
+};

package/utils/dayjs.js

@@ -0,0 +1,174 @@
+import c, { isDayjs as m } from "dayjs";
+import x from "dayjs/plugin/advancedFormat";
+import j from "dayjs/plugin/customParseFormat";
+import $ from "dayjs/plugin/isBetween";
+import F from "dayjs/plugin/quarterOfYear";
+import Y from "dayjs/plugin/weekOfYear";
+import k from "dayjs/plugin/weekYear";
+import u from "lodash/isArray";
+import O from "lodash/isUndefined";
+const v = (t, e, n) => {
+  n = function(r, i) {
+    if (m(r))
+      return r.clone();
+    const f = typeof i == "object" ? i : {};
+    return f.date = r, f.args = arguments, new e(f);
+  };
+  const o = e.prototype, s = o.$utils;
+  o.$utils = function() {
+    const r = s();
+    return r.i = m, r;
+  }, n.isDayjs = m;
+};
+c.extend(v);
+c.extend(j);
+c.extend($);
+c.extend(Y);
+c.extend(x);
+c.extend(k);
+c.extend(F);
+const a = c, y = {
+  add(t, e, n) {
+    return t.add(e, n);
+  },
+  subtract(t, e, n) {
+    return t.subtract(e, n);
+  },
+  startOf(t, e) {
+    return t.startOf(e);
+  },
+  endOf(t, e) {
+    return t.endOf(e);
+  },
+  set(t, e, n) {
+    return t.set(e, n);
+  },
+  isSameWeek(t, e, n, o) {
+    return t.locale({ ...a.Ls[o], weekStart: n }).isSame(e, "week");
+  }
+}, A = {
+  year: 0,
+  month: 1,
+  day: 2,
+  hour: 3,
+  minute: 4,
+  second: 5
+}, T = {}, M = (t, e) => {
+  const n = `${t}|${e || "short"}`;
+  let o = T[n];
+  return o || (o = new Intl.DateTimeFormat("en-US", {
+    hour12: !1,
+    timeZone: t,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }), T[n] = o), o;
+}, S = (t, e) => {
+  const n = new Date(t);
+  return M(e).formatToParts(n);
+}, h = (t, e) => {
+  const n = S(t, e), o = [];
+  for (let g = 0; g < n.length; g += 1) {
+    const { type: p, value: w } = n[g], D = A[p];
+    D >= 0 && (o[D] = parseInt(w, 10));
+  }
+  const s = o[3], r = s === 24 ? 0 : s, i = Date.UTC(
+    o[0],
+    o[1] - 1,
+    o[2],
+    r,
+    o[4],
+    o[5],
+    0
+  );
+  let f = +t;
+  const d = f % 1e3;
+  return f -= d, (i - f) / (60 * 1e3);
+}, U = (t, e, n) => {
+  let o = t - e * 60 * 1e3;
+  const s = h(o, n);
+  if (e === s)
+    return [o, e];
+  o -= (s - e) * 60 * 1e3;
+  const r = h(o, n);
+  return s === r ? [o, s] : [t - Math.min(s, r) * 60 * 1e3, Math.max(s, r)];
+};
+function b(t, e) {
+  return U(
+    t,
+    h((/* @__PURE__ */ new Date()).getTime(), e),
+    e
+  )[1];
+}
+function N(t, e) {
+  return O(t) && !e ? a() : l(a(), t, e);
+}
+function l(t, e, n, o) {
+  if (!t || O(e) && !n)
+    return t;
+  const s = -t.toDate().getTimezoneOffset(), r = O(e) ? n ? b(t.valueOf(), n) : s : e, i = Math.abs(r) <= 16 ? r * 60 : r, f = o ? s - i : i - s;
+  return a(a(t).valueOf() + f * 60 * 1e3);
+}
+function Q(t, e, n) {
+  return l(t, e, n, !0);
+}
+function Z(t) {
+  const e = ["H", "h", "m", "s", "A", "a"];
+  let n = "";
+  return e.some((o) => t.indexOf(o) !== -1 ? (n = `${o}${t.split(` ${o}`)[1]}`, !0) : !1), n || "HH:mm:ss";
+}
+function _(t, e, n, o) {
+  if (!t)
+    return;
+  const s = (i, f) => {
+    if (m(i))
+      return a(i.valueOf());
+    if (typeof i == "string") {
+      const d = a(i, u(e) ? e[f] : e);
+      return d.isValid() ? d : a(i, "YYYY-MM-DD");
+    }
+    return a(i);
+  }, r = (i, f) => n !== void 0 || o ? l(s(i, f), n, o) : s(i, f);
+  return u(t) ? t.map((i, f) => i ? r(i, f) : void 0) : r(t, 0);
+}
+function q(t, e) {
+  const n = t.year(), o = t.month(), s = t.date();
+  if (e) {
+    let r = e;
+    return r = y.set(r, "year", n), r = y.set(r, "month", o), r = y.set(r, "date", s), r;
+  }
+  return t;
+}
+function E(t) {
+  if (!t || !t[0] || !t[1])
+    return t;
+  const e = [...t];
+  return e.sort((n, o) => n.valueOf() - o.valueOf()), e;
+}
+function J(t, e) {
+  return e === void 0 && t === void 0 ? !1 : e && !t || !e && t || a(e).valueOf() !== a(t).valueOf();
+}
+function K(t, e) {
+  return e === void 0 && t === void 0 ? !1 : e && !t || !e && t || u(e) && u(t) && a(e[0]).valueOf() !== a(t[0]).valueOf() || a(e[1]).valueOf() !== a(t[1]).valueOf();
+}
+function X(t, e, n) {
+  return typeof t == "string" && a(t, e).format(u(e) ? e[n] : e) === t;
+}
+export {
+  a as dayjs,
+  _ as getDayjsValue,
+  N as getNow,
+  E as getSortedDayjsArray,
+  Z as getTimeFormat,
+  q as getValueWithTime,
+  K as isDayjsArrayChange,
+  J as isDayjsChange,
+  X as isValidTimeString,
+  y as methods,
+  b as timezoneToOffset,
+  Q as toLocal,
+  l as toTimezone
+};

package/utils/dom.js

@@ -0,0 +1,47 @@
+import { NOOP as c } from "./constant.js";
+const u = function() {
+  try {
+    return !(typeof window < "u" && document !== void 0);
+  } catch {
+    return !0;
+  }
+}(), d = /* @__PURE__ */ function() {
+  return u ? c : function(t, r, n, i) {
+    var o;
+    (o = t == null ? void 0 : t.addEventListener) == null || o.call(t, r, n, i || !1);
+  };
+}(), h = /* @__PURE__ */ function() {
+  return u ? c : function(t, r, n, i) {
+    var o;
+    (o = t == null ? void 0 : t.removeEventListener) == null || o.call(t, r, n, i || !1);
+  };
+}(), a = function(t, r) {
+  if (!t)
+    return !1;
+  if (t.contains)
+    return t.contains(r);
+  let n = r;
+  for (; n; ) {
+    if (n === t)
+      return !0;
+    n = n.parentNode;
+  }
+  return !1;
+}, s = (t) => {
+  const r = t === document.documentElement ? t.clientHeight : t.offsetHeight, n = t === document.documentElement ? t.clientWidth : t.offsetWidth;
+  return t.scrollHeight > r || t.scrollWidth > n;
+}, E = (t, r = document.documentElement) => {
+  const n = [];
+  let i = t;
+  for (; i && i !== r; )
+    s(i) && n.push(i), i = i.parentElement;
+  return n;
+};
+export {
+  a as contains,
+  E as getScrollElements,
+  s as isScrollElement,
+  u as isServerRendering,
+  h as off,
+  d as on
+};

package/utils/fillNBSP.js

@@ -0,0 +1,6 @@
+function l(e) {
+  return typeof e == "string" ? e.replace(/(\s{2,})|(\s{1,}$)/g, (t) => " ".repeat(t.length)) : e;
+}
+export {
+  l as default
+};

package/utils/getHighlightText.js

@@ -0,0 +1,41 @@
+import { jsx as p, Fragment as l } from "react/jsx-runtime";
+import f from "lodash/escapeRegExp";
+import m from "lodash/isArray";
+import { cloneElement as a } from "react";
+function E({
+  nodeList: e,
+  pattern: t,
+  highlightClassName: n
+}) {
+  if (!t)
+    return e;
+  const i = (r) => r && r.props && typeof r.props.children == "string" ? a(
+    r,
+    void 0,
+    /* @__PURE__ */ p(
+      h,
+      {
+        text: r.props.children,
+        keyword: t,
+        highlightClassName: n
+      }
+    )
+  ) : r;
+  return m(e) ? e.map((r) => i(r)) : i(e);
+}
+function h({
+  text: e,
+  keyword: t,
+  highlightClassName: n
+}) {
+  if (!t)
+    return /* @__PURE__ */ p(l, { children: e });
+  t.length > 1e3 && (t = t.slice(0, 1e3));
+  const i = new RegExp(`(${f(t)})`, "i"), r = e.split(i);
+  return /* @__PURE__ */ p(l, { children: r.map(
+    (s, c) => i.test(s) ? /* @__PURE__ */ p("span", { className: n, children: s }, c) : /* @__PURE__ */ p("span", { children: s }, c)
+  ) });
+}
+export {
+  E as default
+};

package/utils/getHotkeyHandler.js

@@ -0,0 +1,27 @@
+import e from "lodash/isNumber";
+import f from "lodash/isString";
+const o = (a) => JSON.stringify({
+  code: a.code,
+  ctrl: !!a.ctrl,
+  shift: !!a.shift,
+  alt: !!a.alt,
+  meta: !!a.meta
+});
+function n(a) {
+  const c = {};
+  return a.forEach((t, r) => {
+    r = e(r) || f(r) ? { code: r } : r, c[o(r)] = t;
+  }), (t) => {
+    const r = o({
+      code: t.code,
+      ctrl: !!t.ctrlKey,
+      shift: !!t.shiftKey,
+      alt: !!t.altKey,
+      meta: !!t.metaKey
+    }), i = c[r];
+    i && (t.stopPropagation(), i(t) === !1 && t.preventDefault());
+  };
+}
+export {
+  n as default
+};

package/utils/getStringLength.js

@@ -0,0 +1,9 @@
+function l(t) {
+  let n = 0;
+  for (let e = 0; e < t.length; e++)
+    t.charCodeAt(e) > 127 || t.charCodeAt(e) === 94 ? n += 2 : n++;
+  return n;
+}
+export {
+  l as default
+};

package/utils/include.js

@@ -0,0 +1,9 @@
+function f(c, t) {
+  const e = {};
+  return Object.keys(c).forEach((n) => {
+    t.indexOf(n) !== -1 && (e[n] = c[n]);
+  }), e;
+}
+export {
+  f as default
+};

package/utils/is.js

@@ -0,0 +1,94 @@
+const t = Object.prototype.toString;
+function d(n) {
+  return t.call(n) === "[object Array]";
+}
+function e(n) {
+  return t.call(n) === "[object Object]";
+}
+function a(n) {
+  return t.call(n) === "[object String]";
+}
+function b(n) {
+  return t.call(n) === "[object Number]" && n === n;
+}
+function $(n) {
+  return t.call(n) === "[object RegExp]";
+}
+function g(n) {
+  return t.call(n) === "[object File]";
+}
+function y(n) {
+  return t.call(n) === "[object Blob]";
+}
+function c(n) {
+  return /^#[a-fA-F0-9]{3}$|#[a-fA-F0-9]{6}$/.test(n);
+}
+function l(n) {
+  return /^rgb\((\s*\d+\s*,?){3}\)$/.test(n);
+}
+function f(n) {
+  return /^rgba\((\s*\d+\s*,\s*){3}\s*\d(\.\d+)?\s*\)$/.test(n);
+}
+function p(n) {
+  return c(n) || l(n) || f(n);
+}
+function j(n) {
+  const r = /^#(?:[0-9a-fA-F]{3}){1,2}$/, s = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/, i = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(1|0|0?\.\d+)\)$/, u = /^hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)$/, o = /^hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*(1|0|0?\.\d+)\)$/;
+  return r.test(n) || s.test(n) || i.test(n) || u.test(n) || o.test(n);
+}
+function O(n) {
+  const r = document.createElement("div");
+  return r.style.color = n, r.style.color !== "";
+}
+function h(n) {
+  return n === void 0;
+}
+function x(n) {
+  return n === null;
+}
+function A(n) {
+  return n == null;
+}
+function E(n) {
+  return typeof n == "function";
+}
+function F(n) {
+  return e(n) && Object.keys(n).length === 0;
+}
+function N(n, r) {
+  return n == null || n === !1 || typeof n == "string" && (r ? n.trim() === "" : n === "");
+}
+function R(n) {
+  return n || n === 0;
+}
+function v(n) {
+  return n === window;
+}
+function w(n) {
+  return e(n) && ("$y" in n && "$M" in n && "$D" in n && "$d" in n && "$H" in n && "$m" in n && "$s" in n || n._isAMomentObject);
+}
+function B(n) {
+  return typeof n == "boolean";
+}
+export {
+  d as isArray,
+  y as isBlob,
+  B as isBoolean,
+  p as isColor,
+  w as isDayjs,
+  F as isEmptyObject,
+  N as isEmptyReactNode,
+  R as isExist,
+  g as isFile,
+  E as isFunction,
+  x as isNull,
+  A as isNullOrUndefined,
+  b as isNumber,
+  e as isObject,
+  $ as isRegExp,
+  a as isString,
+  h as isUndefined,
+  O as isValidColor,
+  j as isValidColor2,
+  v as isWindow
+};

package/utils/keyCode.js

@@ -0,0 +1,48 @@
+const e = {
+  key: "Enter",
+  code: "Enter",
+  keyCode: 13
+}, o = {
+  key: "Escape",
+  code: "Escape",
+  keyCode: 27
+}, c = {
+  key: "Backspace",
+  code: "Backspace",
+  keyCode: 8
+}, r = {
+  key: "Tab",
+  code: "Tab",
+  keyCode: 9
+}, k = {
+  key: " ",
+  code: "Space",
+  keyCode: 32
+}, t = {
+  key: "ArrowUp",
+  code: "ArrowUp",
+  keyCode: 38
+}, d = {
+  key: "ArrowDown",
+  code: "ArrowDown",
+  keyCode: 40
+}, y = {
+  key: "ArrowLeft",
+  code: "ArrowLeft",
+  keyCode: 37
+}, n = {
+  key: "ArrowRight",
+  code: "ArrowRight",
+  keyCode: 39
+};
+export {
+  d as ArrowDown,
+  y as ArrowLeft,
+  n as ArrowRight,
+  t as ArrowUp,
+  c as Backspace,
+  e as Enter,
+  o as Esc,
+  k as Space,
+  r as Tab
+};

package/utils/mergeProp.js

@@ -0,0 +1,11 @@
+function u(f, i, l, s) {
+  const c = i || {}, e = l || {}, o = f || {}, b = s ? new Set(s) : new Set(
+    Object.keys(o).concat(Object.keys(c)).concat(Object.keys(e))
+  ), t = {};
+  return b.forEach((n) => {
+    o[n] !== void 0 ? t[n] = o[n] : n in e ? t[n] = e[n] : n in c && (t[n] = c[n]);
+  }), t;
+}
+export {
+  u as default
+};

package/utils/mergedToString.js

@@ -0,0 +1,14 @@
+import p from "lodash/isNumber";
+import i from "lodash/isString";
+import m from "react";
+const s = (o) => i(o) || p(o);
+function f(o) {
+  const e = [""];
+  return m.Children.forEach(o, (r) => {
+    const n = e.length - 1, t = e[n];
+    s(r) && s(t) ? e[n] = `${t}${r}` : r && r.props && r.props.children && e.push(f(r.props.children));
+  }), e.join("");
+}
+export {
+  f as default
+};