@apdesign/web-react 1.0.0

package/lib/_util/dayjs.js

@@ -0,0 +1,311 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidTimeString = exports.isDayjsArrayChange = exports.isDayjsChange = exports.getSortedDayjsArray = exports.getValueWithTime = exports.getDayjsValue = exports.getTimeFormat = exports.toLocal = exports.toTimezone = exports.getNow = exports.timezoneToOffset = exports.methods = exports.dayjs = void 0;
+var dayjs_1 = __importDefault(require("dayjs"));
+var customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+var isBetween_1 = __importDefault(require("dayjs/plugin/isBetween"));
+var weekOfYear_1 = __importDefault(require("dayjs/plugin/weekOfYear"));
+var advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+var weekYear_1 = __importDefault(require("dayjs/plugin/weekYear"));
+var quarterOfYear_1 = __importDefault(require("dayjs/plugin/quarterOfYear"));
+var is_1 = require("../_util/is");
+var isMoment = (0, dayjs_1.default)()._isAMomentObject;
+if (isMoment) {
+    dayjs_1.default.extend = function () { };
+}
+var overwriteIsDayjs = function (_, Dayjs, dayjs) {
+    dayjs = function (date, c) {
+        if ((0, is_1.isDayjs)(date)) {
+            return date.clone();
+        }
+        var cfg = typeof c === 'object' ? c : {};
+        cfg.date = date;
+        cfg.args = arguments; // eslint-disable-line prefer-rest-params
+        return new Dayjs(cfg);
+    };
+    var proto = Dayjs.prototype;
+    var old$Utils = proto.$utils;
+    proto.$utils = function () {
+        var newUtils = old$Utils();
+        newUtils.i = is_1.isDayjs;
+        return newUtils;
+    };
+    dayjs.isDayjs = is_1.isDayjs;
+};
+dayjs_1.default.extend(overwriteIsDayjs);
+dayjs_1.default.extend(customParseFormat_1.default);
+dayjs_1.default.extend(isBetween_1.default);
+dayjs_1.default.extend(weekOfYear_1.default);
+dayjs_1.default.extend(advancedFormat_1.default);
+dayjs_1.default.extend(weekYear_1.default);
+dayjs_1.default.extend(quarterOfYear_1.default);
+exports.dayjs = dayjs_1.default;
+function startOfWeekTimestamp(date, weekStart) {
+    // 计算 date 与前一个 weekStart 日期的间隔
+    var diff = (date.day() - weekStart + 7) % 7;
+    var startOfWeek = date.clone().startOf('day').subtract(diff, 'day');
+    return startOfWeek.valueOf();
+}
+function isSameWeekMoment(date1, date2, weekStart) {
+    return startOfWeekTimestamp(date1, weekStart) === startOfWeekTimestamp(date2, weekStart);
+}
+// 兼容 moment
+exports.methods = {
+    add: function (time, value, unit) {
+        return isMoment ? time.clone().add(value, unit) : time.add(value, unit);
+    },
+    subtract: function (time, value, unit) {
+        return isMoment ? time.clone().subtract(value, unit) : time.subtract(value, unit);
+    },
+    startOf: function (time, unit) {
+        return isMoment ? time.clone().startOf(unit) : time.startOf(unit);
+    },
+    endOf: function (time, unit) {
+        return isMoment ? time.clone().endOf(unit) : time.endOf(unit);
+    },
+    set: function (time, unit, value) {
+        return isMoment ? time.clone().set(unit, value) : time.set(unit, value);
+    },
+    isSameWeek: function (date1, date2, weekStart, localeName) {
+        return isMoment
+            ? isSameWeekMoment(date1, date2, weekStart)
+            : date1.locale(__assign(__assign({}, exports.dayjs.Ls[localeName]), { weekStart: weekStart })).isSame(date2, 'week');
+    },
+};
+// convert timezone to utcOffset
+// https://github.com/iamkun/dayjs/blob/dev/src/plugin/timezone/index.js#L3
+var typeToPos = {
+    year: 0,
+    month: 1,
+    day: 2,
+    hour: 3,
+    minute: 4,
+    second: 5,
+};
+// Cache time-zone lookups from Intl.DateTimeFormat,
+// as it is a *very* slow method.
+var dtfCache = {};
+var getDateTimeFormat = function (timezone, timeZoneName) {
+    var key = timezone + "|" + (timeZoneName || 'short');
+    var dtf = dtfCache[key];
+    if (!dtf) {
+        dtf = new Intl.DateTimeFormat('en-US', {
+            hour12: false,
+            timeZone: timezone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        dtfCache[key] = dtf;
+    }
+    return dtf;
+};
+var makeFormatParts = function (timestamp, timezone) {
+    var date = new Date(timestamp);
+    var dtf = getDateTimeFormat(timezone);
+    return dtf.formatToParts(date);
+};
+var tzOffset = function (timestamp, timezone) {
+    var formatResult = makeFormatParts(timestamp, timezone);
+    var filled = [];
+    for (var i = 0; i < formatResult.length; i += 1) {
+        var _a = formatResult[i], type = _a.type, value = _a.value;
+        var pos = typeToPos[type];
+        if (pos >= 0) {
+            filled[pos] = parseInt(value, 10);
+        }
+    }
+    var hour = filled[3];
+    // Workaround for the same behavior in different node version
+    // https://github.com/nodejs/node/issues/33027
+    /* istanbul ignore next */
+    var fixedHour = hour === 24 ? 0 : hour;
+    var utcTs = Date.UTC(filled[0], filled[1] - 1, filled[2], fixedHour, filled[4], filled[5], 0);
+    var asTS = +timestamp;
+    var over = asTS % 1000;
+    asTS -= over;
+    return (utcTs - asTS) / (60 * 1000);
+};
+// find the right offset a given local time. The o input is our guess, which determines which
+// offset we'll pick in ambiguous cases (e.g. there are two 3 AMs b/c Fallback DST)
+// https://github.com/moment/luxon/blob/master/src/datetime.js#L76
+var fixOffset = function (localTS, o0, tz) {
+    // Our UTC time is just a guess because our offset is just a guess
+    var utcGuess = localTS - o0 * 60 * 1000;
+    // Test whether the zone matches the offset for this ts
+    var o2 = tzOffset(utcGuess, tz);
+    // If so, offset didn't change and we're done
+    if (o0 === o2) {
+        return [utcGuess, o0];
+    }
+    // If not, change the ts by the difference in the offset
+    utcGuess -= (o2 - o0) * 60 * 1000;
+    // If that gives us the local time we want, we're done
+    var o3 = tzOffset(utcGuess, tz);
+    if (o2 === o3) {
+        return [utcGuess, o2];
+    }
+    // If it's different, we're in a hole time.
+    // The offset has changed, but the we don't adjust the time
+    return [localTS - Math.min(o2, o3) * 60 * 1000, Math.max(o2, o3)];
+};
+function timezoneToOffset(inputTs, timezone) {
+    return fixOffset(inputTs, tzOffset(new Date().getTime(), timezone), timezone)[1];
+}
+exports.timezoneToOffset = timezoneToOffset;
+// get local now time
+function getNow(utcOffset, timezone) {
+    return (0, is_1.isUndefined)(utcOffset) && !timezone ? (0, exports.dayjs)() : toTimezone((0, exports.dayjs)(), utcOffset, timezone);
+}
+exports.getNow = getNow;
+// convert local date to specify timezone date
+function toTimezone(time, utcOffset, timezone, local) {
+    if (!time || ((0, is_1.isUndefined)(utcOffset) && !timezone)) {
+        return time;
+    }
+    var localOffset = -time.toDate().getTimezoneOffset();
+    var uOffset = (0, is_1.isUndefined)(utcOffset)
+        ? !timezone
+            ? localOffset
+            : timezoneToOffset(time.valueOf(), timezone)
+        : utcOffset;
+    var timezoneOffset = Math.abs(uOffset) <= 16 ? uOffset * 60 : uOffset;
+    var diffOffset = local ? localOffset - timezoneOffset : timezoneOffset - localOffset;
+    return (0, exports.dayjs)((0, exports.dayjs)(time).valueOf() + diffOffset * 60 * 1000);
+}
+exports.toTimezone = toTimezone;
+// convert specify timezone date to local date
+function toLocal(time, utcOffset, timezone) {
+    return toTimezone(time, utcOffset, timezone, true);
+}
+exports.toLocal = toLocal;
+function getTimeFormat(format) {
+    var units = ['H', 'h', 'm', 's', 'A', 'a'];
+    var timeFormat = '';
+    units.some(function (unit) {
+        if (format.indexOf(unit) !== -1) {
+            timeFormat = "" + unit + format.split(" " + unit)[1];
+            return true;
+        }
+        return false;
+    });
+    return timeFormat || 'HH:mm:ss';
+}
+exports.getTimeFormat = getTimeFormat;
+function getDayjsValue(time, format, utcOffset, timezone) {
+    if (!time) {
+        return undefined;
+    }
+    var formatValue = function (value, i) {
+        if ((0, is_1.isDayjs)(value)) {
+            return (0, exports.dayjs)(value.valueOf());
+        }
+        if (typeof value === 'string') {
+            var dv = (0, exports.dayjs)(value, (0, is_1.isArray)(format) ? format[i] : format);
+            return dv.isValid() ? dv : (0, exports.dayjs)(value, 'YYYY-MM-DD');
+        }
+        return (0, exports.dayjs)(value);
+    };
+    // if set a timezone, convert to timezone date
+    var getRealTime = function (t, i) {
+        return utcOffset !== undefined || timezone
+            ? toTimezone(formatValue(t, i), utcOffset, timezone)
+            : formatValue(t, i);
+    };
+    if ((0, is_1.isArray)(time)) {
+        return time.map(function (t, i) { return (t ? getRealTime(t, i) : undefined); });
+    }
+    return getRealTime(time, 0);
+}
+exports.getDayjsValue = getDayjsValue;
+function getValueWithTime(date, time) {
+    var y = date.year();
+    var m = date.month();
+    var d = date.date();
+    if (time) {
+        var returnTime = time;
+        returnTime = exports.methods.set(returnTime, 'year', y);
+        returnTime = exports.methods.set(returnTime, 'month', m);
+        returnTime = exports.methods.set(returnTime, 'date', d);
+        return returnTime;
+    }
+    return date;
+}
+exports.getValueWithTime = getValueWithTime;
+function getSortedDayjsArray(values) {
+    if (!values || !values[0] || !values[1]) {
+        return values;
+    }
+    var newValues = __spreadArray([], __read(values), false);
+    newValues.sort(function (a, b) { return a.valueOf() - b.valueOf(); });
+    return newValues;
+}
+exports.getSortedDayjsArray = getSortedDayjsArray;
+function isDayjsChange(prevValue, currentValue) {
+    if (currentValue === undefined && prevValue === undefined) {
+        return false;
+    }
+    return ((currentValue && !prevValue) ||
+        (!currentValue && prevValue) ||
+        (0, exports.dayjs)(currentValue).valueOf() !== (0, exports.dayjs)(prevValue).valueOf());
+}
+exports.isDayjsChange = isDayjsChange;
+function isDayjsArrayChange(prevValue, currentValue) {
+    if (currentValue === undefined && prevValue === undefined) {
+        return false;
+    }
+    return ((currentValue && !prevValue) ||
+        (!currentValue && prevValue) ||
+        ((0, is_1.isArray)(currentValue) &&
+            (0, is_1.isArray)(prevValue) &&
+            (0, exports.dayjs)(currentValue[0]).valueOf() !== (0, exports.dayjs)(prevValue[0]).valueOf()) ||
+        (0, exports.dayjs)(currentValue[1]).valueOf() !== (0, exports.dayjs)(prevValue[1]).valueOf());
+}
+exports.isDayjsArrayChange = isDayjsArrayChange;
+function isValidTimeString(str, format, index) {
+    return (typeof str === 'string' &&
+        (0, exports.dayjs)(str, format).format((0, is_1.isArray)(format) ? format[index] : format) === str);
+}
+exports.isValidTimeString = isValidTimeString;

package/lib/_util/dom.d.ts

@@ -0,0 +1,12 @@
+export declare const isServerRendering: boolean;
+export declare const on: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const off: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const contains: (root: HTMLElement, ele: any) => boolean;
+export declare const isScrollElement: (element: HTMLElement) => boolean;
+/**
+ * 从当前节点向上查找所有的滚动元素
+ * @param container 当前节点
+ * @param top 查找到 top 节点就终止，不再继续查找
+ * @returns
+ */
+export declare const getScrollElements: (container: HTMLElement, top?: HTMLElement) => HTMLElement[];

package/lib/_util/dom.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScrollElements = exports.isScrollElement = exports.contains = exports.off = exports.on = exports.isServerRendering = void 0;
+var constant_1 = require("./constant");
+exports.isServerRendering = (function () {
+    try {
+        return !(typeof window !== 'undefined' && document !== undefined);
+    }
+    catch (e) {
+        return true;
+    }
+})();
+exports.on = (function () {
+    if (exports.isServerRendering) {
+        return constant_1.NOOP;
+    }
+    return function (element, event, handler, options) {
+        element && element.addEventListener(event, handler, options || false);
+    };
+})();
+exports.off = (function () {
+    if (exports.isServerRendering) {
+        return constant_1.NOOP;
+    }
+    return function (element, event, handler, options) {
+        element && element.removeEventListener(event, handler, options || false);
+    };
+})();
+var contains = function (root, ele) {
+    if (!root) {
+        return false;
+    }
+    if (root.contains) {
+        return root.contains(ele);
+    }
+    var node = ele;
+    while (node) {
+        if (node === root) {
+            return true;
+        }
+        node = node.parentNode;
+    }
+    return false;
+};
+exports.contains = contains;
+var isScrollElement = function (element) {
+    var clientHeight = element === document.documentElement ? element.clientHeight : element.offsetHeight;
+    var clientWidth = element === document.documentElement ? element.clientWidth : element.offsetWidth;
+    return element.scrollHeight > clientHeight || element.scrollWidth > clientWidth;
+};
+exports.isScrollElement = isScrollElement;
+/**
+ * 从当前节点向上查找所有的滚动元素
+ * @param container 当前节点
+ * @param top 查找到 top 节点就终止，不再继续查找
+ * @returns
+ */
+var getScrollElements = function (container, top) {
+    if (top === void 0) { top = document.documentElement; }
+    var scrollElements = [];
+    var element = container;
+    while (element && element !== top) {
+        if ((0, exports.isScrollElement)(element)) {
+            scrollElements.push(element);
+        }
+        element = element.parentElement;
+    }
+    return scrollElements;
+};
+exports.getScrollElements = getScrollElements;

package/lib/_util/fillNBSP.d.ts

@@ -0,0 +1 @@
+export default function (str: any): any;

package/lib/_util/fillNBSP.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Replace empty string to  
+function default_1(str) {
+    return typeof str === 'string'
+        ? str.replace(/(\s{2,})|(\s{1,}$)/g, function ($0) { return '\u00A0'.repeat($0.length); })
+        : str;
+}
+exports.default = default_1;

package/lib/_util/getHighlightText.d.ts

@@ -0,0 +1,5 @@
+export default function getHighlightText<T>({ nodeList, pattern, highlightClassName, }: {
+    nodeList: T;
+    pattern: string;
+    highlightClassName: string;
+}): T;

package/lib/_util/getHighlightText.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var escapeRegExp_1 = __importDefault(require("lodash/escapeRegExp"));
+var react_1 = __importStar(require("react"));
+var is_1 = require("./is");
+function getHighlightText(_a) {
+    var nodeList = _a.nodeList, pattern = _a.pattern, highlightClassName = _a.highlightClassName;
+    if (!pattern) {
+        return nodeList;
+    }
+    var transformNode = function (node) {
+        if (node && node.props && typeof node.props.children === 'string') {
+            return (0, react_1.cloneElement)(node, undefined, react_1.default.createElement(HighlightText, { text: node.props.children, keyword: pattern, highlightClassName: highlightClassName }));
+        }
+        return node;
+    };
+    return (0, is_1.isArray)(nodeList) ? nodeList.map(function (node) { return transformNode(node); }) : transformNode(nodeList);
+}
+exports.default = getHighlightText;
+function HighlightText(_a) {
+    var text = _a.text, keyword = _a.keyword, highlightClassName = _a.highlightClassName;
+    if (!keyword)
+        return react_1.default.createElement(react_1.default.Fragment, null, text);
+    // limit keyword length to avoid Regular expression too large error
+    if (keyword.length > 1000) {
+        keyword = keyword.slice(0, 1000);
+    }
+    // 注意这里的括号，这里使用了带capture group功能的正则，来split字符串
+    // 从而在strArr中可以保留匹配文本
+    var re = new RegExp("(" + (0, escapeRegExp_1.default)(keyword) + ")", 'i');
+    var strArr = text.split(re);
+    return (react_1.default.createElement(react_1.default.Fragment, null, strArr.map(function (item, index) {
+        return re.test(item) ? (react_1.default.createElement("span", { key: index, className: highlightClassName }, item)) : (react_1.default.createElement("span", { key: index }, item));
+    })));
+}

package/lib/_util/getHotkeyHandler.d.ts

@@ -0,0 +1,16 @@
+export interface Key {
+    /** Keyboard key code */
+    code: number;
+    /** Ctrl / ⌃ */
+    ctrl?: boolean;
+    /** Shift key */
+    shift?: boolean;
+    /** Alt / ⌥ */
+    alt?: boolean;
+    /** meta ⌘ / ⊞ */
+    meta?: boolean;
+}
+/**
+ * @param hotkeyMap - 快捷键描述对象
+ */
+export default function getHotkeyHandler(hotkeyMap: Map<Key | number, Function>): (event: KeyboardEvent) => void;

package/lib/_util/getHotkeyHandler.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var stringifyHotkey = function (k) {
+    return JSON.stringify({
+        code: k.code,
+        ctrl: !!k.ctrl,
+        shift: !!k.shift,
+        alt: !!k.alt,
+        meta: !!k.meta,
+    });
+};
+/**
+ * @param hotkeyMap - 快捷键描述对象
+ */
+function getHotkeyHandler(hotkeyMap) {
+    var map = {};
+    hotkeyMap.forEach(function (callback, hotkey) {
+        hotkey = typeof hotkey === 'number' ? { code: hotkey } : hotkey;
+        map[stringifyHotkey(hotkey)] = callback;
+    });
+    return function (event) {
+        var key = stringifyHotkey({
+            code: event.keyCode || event.which,
+            ctrl: !!event.ctrlKey,
+            shift: !!event.shiftKey,
+            alt: !!event.altKey,
+            meta: !!event.metaKey,
+        });
+        var callback = map[key];
+        if (callback) {
+            event.stopPropagation();
+            if (callback(event) === false) {
+                event.preventDefault();
+            }
+        }
+    };
+}
+exports.default = getHotkeyHandler;

package/lib/_util/getStringLength.d.ts

@@ -0,0 +1 @@
+export default function (str: string): number;

package/lib/_util/getStringLength.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// 计算字符串长度，中文字符占两个长度
+function default_1(str) {
+    var len = 0;
+    for (var i = 0; i < str.length; i++) {
+        if (str.charCodeAt(i) > 127 || str.charCodeAt(i) === 94) {
+            len += 2;
+        }
+        else {
+            len++;
+        }
+    }
+    return len;
+}
+exports.default = default_1;

package/lib/_util/hooks/useComputedState.d.ts

@@ -0,0 +1,4 @@
+import { ComponentState, PropsWithoutRef } from 'react';
+declare type Dependency<T> = PropsWithoutRef<T> | ComponentState;
+export default function useComputedState<T>(computed: () => any, deps: Dependency<T>[]): any;
+export {};

package/lib/_util/hooks/useComputedState.js

@@ -0,0 +1,28 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+function useComputedState(computed, deps) {
+    var _a = __read((0, react_1.useState)(computed()), 2), state = _a[0], setState = _a[1];
+    (0, react_1.useEffect)(function () {
+        var newState = computed();
+        setState(newState);
+    }, [deps]);
+    return state;
+}
+exports.default = useComputedState;

package/lib/_util/hooks/useCreate.d.ts

@@ -0,0 +1 @@
+export default function useCreate(fn: any): void;

package/lib/_util/hooks/useCreate.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var React = __importStar(require("react"));
+function useCreate(fn) {
+    var hasBeenCalled = React.useRef(false);
+    if (hasBeenCalled.current === false) {
+        fn();
+        hasBeenCalled.current = true;
+    }
+}
+exports.default = useCreate;

package/lib/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function useForceUpdate(): import("react").DispatchWithoutAction;

package/lib/_util/hooks/useForceUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+function useForceUpdate() {
+    var _a = __read((0, react_1.useReducer)(function (v) { return v + 1; }, 0), 2), dispatch = _a[1];
+    return dispatch;
+}
+exports.default = useForceUpdate;

package/lib/_util/hooks/useId.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provide unique component name while using this hook
+ * In react 18, React.useId is a better way to choose
+ * Related issue: https://github.com/arco-design/arco-design/issues/958
+ */
+export default function useId(prefix: string): string | undefined;