@hanwenbo/x-web-pro-components 0.0.1

package/es/components/provider/index.js

@@ -0,0 +1,117 @@
+var _excluded = ["prefixCls", "valueTypeMap", "token", "hashed", "dark", "intl", "autoClearCache", "needDeps", "children"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { useContext, useMemo } from 'react';
+import { ConfigProvider } from '@hanwenbo/x-web-ui/configProvider';
+import { ProProvider } from "./context";
+import { zhCNIntl } from "./intl";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+export * from "./context";
+export * from "./intl";
+export * from "./types";
+export * from "./useStyle";
+var getNodeEnv = function getNodeEnv() {
+  var _process;
+  return (_process = globalThis.process) === null || _process === void 0 || (_process = _process.env) === null || _process === void 0 ? void 0 : _process.NODE_ENV;
+};
+export var isNeedOpenHash = function isNeedOpenHash() {
+  var _getNodeEnv;
+  var env = (_getNodeEnv = getNodeEnv()) === null || _getNodeEnv === void 0 ? void 0 : _getNodeEnv.toUpperCase();
+  if (env === 'TEST' || env === 'DEV') {
+    return false;
+  }
+  return true;
+};
+export var useProConfig = function useProConfig() {
+  return useContext(ProProvider);
+};
+export var useIntl = function useIntl() {
+  return useProConfig().intl;
+};
+export var ConfigConsumer = ProProvider.Consumer;
+export var IntlConsumer = ProProvider.Consumer;
+var hashString = function hashString(input) {
+  var hash = 5381;
+  for (var index = 0; index < input.length; index += 1) {
+    hash = hash * 33 ^ input.charCodeAt(index);
+  }
+  return (hash >>> 0).toString(36);
+};
+var mergeToken = function mergeToken(parentToken, currentToken, prefixCls) {
+  var mergedToken = _objectSpread(_objectSpread({}, parentToken || {}), currentToken || {});
+  mergedToken.antCls = mergedToken.antCls || '.x-web-ui';
+  mergedToken.proComponentsCls = mergedToken.proComponentsCls || ".".concat(prefixCls);
+  mergedToken.themeId = mergedToken.themeId || 0;
+  return mergedToken;
+};
+export var ProConfigProvider = function ProConfigProvider(_ref) {
+  var _ref2, _ref3;
+  var prefixCls = _ref.prefixCls,
+    _ref$valueTypeMap = _ref.valueTypeMap,
+    valueTypeMap = _ref$valueTypeMap === void 0 ? {} : _ref$valueTypeMap,
+    token = _ref.token,
+    hashed = _ref.hashed,
+    dark = _ref.dark,
+    _ref$intl = _ref.intl,
+    intl = _ref$intl === void 0 ? zhCNIntl : _ref$intl,
+    _ref$autoClearCache = _ref.autoClearCache,
+    autoClearCache = _ref$autoClearCache === void 0 ? false : _ref$autoClearCache,
+    _ref$needDeps = _ref.needDeps,
+    needDeps = _ref$needDeps === void 0 ? false : _ref$needDeps,
+    children = _ref.children,
+    configProviderProps = _objectWithoutProperties(_ref, _excluded);
+  var parentConfig = useContext(ProProvider);
+  var isNeedDepsPassThrough = needDeps && parentConfig.hashId !== undefined && Object.keys({
+    children: children,
+    needDeps: needDeps
+  }).sort().join('-') === 'children-needDeps';
+  var resolvedHashed = (_ref2 = hashed !== null && hashed !== void 0 ? hashed : parentConfig.hashed) !== null && _ref2 !== void 0 ? _ref2 : isNeedOpenHash();
+  var mergedPrefixCls = (_ref3 = prefixCls !== null && prefixCls !== void 0 ? prefixCls : parentConfig.prefixCls) !== null && _ref3 !== void 0 ? _ref3 : 'x-web-pro';
+  var mergedIntl = intl || parentConfig.intl || zhCNIntl;
+  var mergedToken = useMemo(function () {
+    return mergeToken(parentConfig.token, token, mergedPrefixCls);
+  }, [mergedPrefixCls, parentConfig.token, token]);
+  var mergedCache = useMemo(function () {
+    if (!autoClearCache && parentConfig.cache) {
+      return parentConfig.cache;
+    }
+    return new Map();
+  }, [autoClearCache, parentConfig.cache]);
+  var computedHashId = useMemo(function () {
+    if (!resolvedHashed) {
+      return '';
+    }
+    return "".concat(mergedPrefixCls, "-").concat(hashString(JSON.stringify(mergedToken)));
+  }, [mergedPrefixCls, mergedToken, resolvedHashed]);
+  var contextValue = useMemo(function () {
+    return {
+      cache: mergedCache,
+      dark: dark !== null && dark !== void 0 ? dark : parentConfig.dark,
+      hashId: computedHashId,
+      hashed: resolvedHashed,
+      intl: mergedIntl,
+      prefixCls: mergedPrefixCls,
+      token: mergedToken,
+      valueTypeMap: _objectSpread(_objectSpread({}, parentConfig.valueTypeMap || {}), valueTypeMap)
+    };
+  }, [computedHashId, dark, mergedCache, mergedIntl, mergedPrefixCls, mergedToken, parentConfig.dark, parentConfig.valueTypeMap, resolvedHashed, valueTypeMap]);
+  if (isNeedDepsPassThrough) {
+    return /*#__PURE__*/_jsx(_Fragment, {
+      children: children
+    });
+  }
+  return /*#__PURE__*/_jsx(ConfigProvider, _objectSpread(_objectSpread({}, configProviderProps), {}, {
+    children: /*#__PURE__*/_jsx(ProProvider.Provider, {
+      value: contextValue,
+      children: children
+    })
+  }));
+};
+export default ProProvider;

package/es/components/provider/intl.d.ts

@@ -0,0 +1,38 @@
+import type { IntlType } from './types';
+export declare const createIntl: (locale: string, messages?: Record<string, string>) => IntlType;
+export declare const mnMNIntl: IntlType;
+export declare const arEGIntl: IntlType;
+export declare const zhCNIntl: IntlType;
+export declare const enUSIntl: IntlType;
+export declare const enGBIntl: IntlType;
+export declare const viVNIntl: IntlType;
+export declare const itITIntl: IntlType;
+export declare const jaJPIntl: IntlType;
+export declare const esESIntl: IntlType;
+export declare const caESIntl: IntlType;
+export declare const ruRUIntl: IntlType;
+export declare const srRSIntl: IntlType;
+export declare const msMYIntl: IntlType;
+export declare const zhTWIntl: IntlType;
+export declare const zhHKIntl: IntlType;
+export declare const frFRIntl: IntlType;
+export declare const ptBRIntl: IntlType;
+export declare const koKRIntl: IntlType;
+export declare const idIDIntl: IntlType;
+export declare const deDEIntl: IntlType;
+export declare const faIRIntl: IntlType;
+export declare const trTRIntl: IntlType;
+export declare const plPLIntl: IntlType;
+export declare const hrHRIntl: IntlType;
+export declare const thTHIntl: IntlType;
+export declare const csCZIntl: IntlType;
+export declare const skSKIntl: IntlType;
+export declare const heILIntl: IntlType;
+export declare const ukUAIntl: IntlType;
+export declare const uzUZIntl: IntlType;
+export declare const nlNLIntl: IntlType;
+export declare const roROIntl: IntlType;
+export declare const svSEIntl: IntlType;
+export declare const intlMap: Record<string, IntlType>;
+export declare const intlMapKeys: string[];
+export declare const findIntlKeyByAntdLocaleKey: <T extends string>(localeKey?: T | undefined) => T | undefined;

package/es/components/provider/intl.js

@@ -0,0 +1,112 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var createMessages = function createMessages(locale, overrides) {
+  return _objectSpread({
+    moneySymbol: locale.toLowerCase().startsWith('en') ? '$' : locale.toLowerCase().startsWith('zh') ? '¥' : '¥',
+    'tableForm.search': locale.toLowerCase().startsWith('zh') ? '查询' : 'Search',
+    'tableForm.reset': locale.toLowerCase().startsWith('zh') ? '重置' : 'Reset',
+    'tableForm.option': locale.toLowerCase().startsWith('zh') ? '操作' : 'Actions',
+    'tableForm.expand': locale.toLowerCase().startsWith('zh') ? '收起' : 'Collapse',
+    'tableForm.collapsed': locale.toLowerCase().startsWith('zh') ? '展开' : 'Expand',
+    'modalForm.submit': locale.toLowerCase().startsWith('zh') ? '提交' : 'Submit',
+    'modalForm.cancel': locale.toLowerCase().startsWith('zh') ? '取消' : 'Cancel',
+    'tableForm.empty': locale.toLowerCase().startsWith('zh') ? '暂无数据' : undefined
+  }, overrides);
+};
+var zhCNMessages = createMessages('zh-CN');
+export var createIntl = function createIntl(locale) {
+  var messages = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var normalizedLocale = locale.replace(/_/g, '-');
+  var mergedMessages = createMessages(normalizedLocale, messages);
+  return {
+    locale: normalizedLocale,
+    getMessage: function getMessage(id, defaultMessage) {
+      if (mergedMessages[id]) {
+        return mergedMessages[id];
+      }
+      if (normalizedLocale.toLowerCase() !== 'zh-cn' && zhCNMessages[id]) {
+        return zhCNMessages[id];
+      }
+      return defaultMessage || id;
+    }
+  };
+};
+export var mnMNIntl = createIntl('mn-MN');
+export var arEGIntl = createIntl('ar-EG');
+export var zhCNIntl = createIntl('zh-CN');
+export var enUSIntl = createIntl('en-US');
+export var enGBIntl = createIntl('en-GB');
+export var viVNIntl = createIntl('vi-VN');
+export var itITIntl = createIntl('it-IT');
+export var jaJPIntl = createIntl('ja-JP');
+export var esESIntl = createIntl('es-ES');
+export var caESIntl = createIntl('ca-ES');
+export var ruRUIntl = createIntl('ru-RU');
+export var srRSIntl = createIntl('sr-RS');
+export var msMYIntl = createIntl('ms-MY');
+export var zhTWIntl = createIntl('zh-TW');
+export var zhHKIntl = createIntl('zh-HK');
+export var frFRIntl = createIntl('fr-FR');
+export var ptBRIntl = createIntl('pt-BR');
+export var koKRIntl = createIntl('ko-KR');
+export var idIDIntl = createIntl('id-ID');
+export var deDEIntl = createIntl('de-DE');
+export var faIRIntl = createIntl('fa-IR');
+export var trTRIntl = createIntl('tr-TR');
+export var plPLIntl = createIntl('pl-PL');
+export var hrHRIntl = createIntl('hr-HR');
+export var thTHIntl = createIntl('th-TH');
+export var csCZIntl = createIntl('cs-CZ');
+export var skSKIntl = createIntl('sk-SK');
+export var heILIntl = createIntl('he-IL');
+export var ukUAIntl = createIntl('uk-UA');
+export var uzUZIntl = createIntl('uz-UZ');
+export var nlNLIntl = createIntl('nl-NL');
+export var roROIntl = createIntl('ro-RO');
+export var svSEIntl = createIntl('sv-SE');
+export var intlMap = {
+  'ar-EG': arEGIntl,
+  'ca-ES': caESIntl,
+  'cs-CZ': csCZIntl,
+  'de-DE': deDEIntl,
+  'en-GB': enGBIntl,
+  'en-US': enUSIntl,
+  'es-ES': esESIntl,
+  'fa-IR': faIRIntl,
+  'fr-FR': frFRIntl,
+  'he-IL': heILIntl,
+  'hr-HR': hrHRIntl,
+  'id-ID': idIDIntl,
+  'it-IT': itITIntl,
+  'ja-JP': jaJPIntl,
+  'ko-KR': koKRIntl,
+  'mn-MN': mnMNIntl,
+  'ms-MY': msMYIntl,
+  'nl-NL': nlNLIntl,
+  'pl-PL': plPLIntl,
+  'pt-BR': ptBRIntl,
+  'ro-RO': roROIntl,
+  'ru-RU': ruRUIntl,
+  'sk-SK': skSKIntl,
+  'sr-RS': srRSIntl,
+  'sv-SE': svSEIntl,
+  'th-TH': thTHIntl,
+  'tr-TR': trTRIntl,
+  'uk-UA': ukUAIntl,
+  'uz-UZ': uzUZIntl,
+  'vi-VN': viVNIntl,
+  'zh-CN': zhCNIntl,
+  'zh-HK': zhHKIntl,
+  'zh-TW': zhTWIntl
+};
+export var intlMapKeys = Object.keys(intlMap);
+export var findIntlKeyByAntdLocaleKey = function findIntlKeyByAntdLocaleKey(localeKey) {
+  var localeName = (localeKey || 'zh-CN').toLowerCase().replace(/_/g, '-');
+  return intlMapKeys.find(function (intlKey) {
+    return intlKey.toLowerCase() === localeName;
+  });
+};

package/es/components/provider/types.d.ts

@@ -0,0 +1,37 @@
+import type React from 'react';
+import type { ProFieldFCMode, ProRenderFieldPropsType, ProSchemaValueEnumType } from '../../types';
+import type { IntlType } from './intl';
+export type { ProFieldFCMode, ProRenderFieldPropsType, ProSchemaValueEnumType };
+export declare type ParamsType = Record<string, any>;
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Record<string, any> ? DeepPartial<T[P]> : T[P];
+};
+export declare type ProTokenType = Record<string, any>;
+export declare type ProFieldFCRenderProps = {
+    label?: React.ReactNode;
+    light?: boolean;
+    mode?: ProFieldFCMode;
+    onChange?: (...args: any[]) => void;
+    placeholder?: string | string[];
+    readonly?: boolean;
+    value?: any;
+};
+export declare type BaseProFieldFC = {
+    fieldProps?: any;
+    label?: React.ReactNode;
+    light?: boolean;
+    mode?: ProFieldFCMode;
+    proFieldKey?: React.Key;
+    text: React.ReactNode;
+    valueEnum?: Record<string, ProSchemaValueEnumType | React.ReactNode> | Map<any, any>;
+};
+export declare type ConfigContextPropsType = {
+    cache?: Map<any, any>;
+    dark?: boolean;
+    hashId?: string;
+    hashed?: boolean;
+    intl: IntlType;
+    prefixCls: string;
+    token: ProTokenType;
+    valueTypeMap: Record<string, ProRenderFieldPropsType>;
+};

package/es/components/provider/types.js

@@ -0,0 +1 @@
+export {};

package/es/components/provider/useStyle/index.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { ProTokenType } from '../types';
+export declare const setAlpha: (baseColor: string, alpha: number) => string;
+export declare const lighten: (baseColor: string, brightness: number) => string;
+export declare type CSSObject = Record<string, any>;
+export declare type CSSInterpolation = CSSObject | string | number | Array<CSSObject | string | number>;
+export declare type GenerateStyle<ComponentToken extends object = Record<string, any>, ReturnType = CSSInterpolation> = (token: ComponentToken, ...rest: any[]) => ReturnType;
+export declare type ProAliasToken = ProTokenType & {
+    themeId: number;
+    proComponentsCls: string;
+    antCls: string;
+};
+export declare const proTheme: {
+    useToken: () => {
+        hashId: string;
+        theme: {
+            id: number;
+        };
+        token: ProAliasToken;
+    };
+};
+export declare const resetComponent: (token: ProAliasToken) => CSSObject;
+export declare const operationUnit: (token: ProAliasToken) => CSSObject;
+export declare type UseStyleResult = {
+    wrapSSR: (node: React.ReactElement) => React.ReactElement;
+    hashId: string;
+};
+export declare function useStyle(componentName: string, styleFn: (token: ProAliasToken) => CSSInterpolation): UseStyleResult;

package/es/components/provider/useStyle/index.js

@@ -0,0 +1,208 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { useEffect, useMemo } from 'react';
+import { useProConfig } from "../context";
+var clamp = function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};
+var normalizeHex = function normalizeHex(color) {
+  var raw = color.replace('#', '').trim();
+  if (raw.length === 3) {
+    return raw.split('').map(function (char) {
+      return char + char;
+    }).join('');
+  }
+  return raw.length === 6 ? raw : '';
+};
+var toRgb = function toRgb(color) {
+  var hex = normalizeHex(color);
+  if (!hex) {
+    return undefined;
+  }
+  return {
+    r: parseInt(hex.slice(0, 2), 16),
+    g: parseInt(hex.slice(2, 4), 16),
+    b: parseInt(hex.slice(4, 6), 16)
+  };
+};
+export var setAlpha = function setAlpha(baseColor, alpha) {
+  var rgb = toRgb(baseColor);
+  if (!rgb) {
+    return baseColor;
+  }
+  return "rgba(".concat(rgb.r, ", ").concat(rgb.g, ", ").concat(rgb.b, ", ").concat(clamp(alpha, 0, 1), ")");
+};
+export var lighten = function lighten(baseColor, brightness) {
+  var rgb = toRgb(baseColor);
+  if (!rgb) {
+    return baseColor;
+  }
+  var ratio = clamp(brightness, 0, 100) / 100;
+  var toHex = function toHex(value) {
+    return Math.round(value).toString(16).padStart(2, '0');
+  };
+  return "#".concat(toHex(rgb.r + (255 - rgb.r) * ratio)).concat(toHex(rgb.g + (255 - rgb.g) * ratio)).concat(toHex(rgb.b + (255 - rgb.b) * ratio));
+};
+export var proTheme = {
+  useToken: function useToken() {
+    var _useProConfig = useProConfig(),
+      hashId = _useProConfig.hashId,
+      hashed = _useProConfig.hashed,
+      prefixCls = _useProConfig.prefixCls,
+      token = _useProConfig.token;
+    return {
+      hashId: hashed ? hashId || "".concat(prefixCls, "-hash") : '',
+      theme: {
+        id: 0
+      },
+      token: _objectSpread(_objectSpread({}, token), {}, {
+        antCls: '.x-web-ui',
+        proComponentsCls: ".".concat(prefixCls),
+        themeId: 0
+      })
+    };
+  }
+};
+export var resetComponent = function resetComponent(token) {
+  return {
+    boxSizing: 'border-box',
+    color: token.colorText || 'inherit',
+    fontSize: token.fontSize || 14,
+    lineHeight: token.lineHeight || 1.5,
+    margin: 0,
+    padding: 0,
+    '*, *::before, *::after': {
+      boxSizing: 'border-box'
+    }
+  };
+};
+export var operationUnit = function operationUnit(token) {
+  return {
+    color: token.colorLink || token.colorPrimary || 'inherit',
+    cursor: 'pointer',
+    outline: 'none',
+    transition: 'color 0.2s'
+  };
+};
+var styleUsageMap = new Map();
+var toKebabCase = function toKebabCase(value) {
+  return value.replace(/[A-Z]/g, function (match) {
+    return "-".concat(match.toLowerCase());
+  });
+};
+var isPlainObject = function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === '[object Object]';
+};
+var serializeDeclarations = function serializeDeclarations(styles) {
+  return Object.entries(styles).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      value = _ref2[1];
+    return value !== undefined && value !== null && _typeof(value) !== 'object';
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    return "".concat(toKebabCase(key), ":").concat(String(value), ";");
+  }).join('');
+};
+var serializeRules = function serializeRules(selector, styles) {
+  var declarations = serializeDeclarations(styles);
+  var nestedRules = Object.entries(styles).filter(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      value = _ref6[1];
+    return value !== undefined && value !== null && _typeof(value) === 'object';
+  }).flatMap(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+      key = _ref8[0],
+      value = _ref8[1];
+    if (!isPlainObject(value) && !Array.isArray(value)) {
+      return [];
+    }
+    if (key.startsWith('@')) {
+      return "".concat(key, "{").concat(serializeRules(selector, value), "}");
+    }
+    var nextSelector = key.includes('&') ? key.replace(/&/g, selector) : "".concat(selector, " ").concat(key);
+    return serializeRules(nextSelector, value);
+  });
+  var currentRule = declarations ? "".concat(selector, "{").concat(declarations, "}") : '';
+  return [currentRule].concat(_toConsumableArray(nestedRules)).filter(Boolean).join('');
+};
+var styleToCssText = function styleToCssText(selector, style) {
+  if (typeof style === 'string' || typeof style === 'number') {
+    return "".concat(selector, "{").concat(String(style), "}");
+  }
+  if (Array.isArray(style)) {
+    return style.map(function (item) {
+      return styleToCssText(selector, item);
+    }).join('');
+  }
+  if (!style || !isPlainObject(style)) {
+    return '';
+  }
+  return serializeRules(selector, style);
+};
+export function useStyle(componentName, styleFn) {
+  var _useProConfig2 = useProConfig(),
+    hashId = _useProConfig2.hashId,
+    hashed = _useProConfig2.hashed,
+    token = _useProConfig2.token;
+  var mergedHashId = hashed ? "".concat(hashId || 'x-web-pro', "-").concat(componentName) : '';
+  var styleId = mergedHashId ? "x-web-pro-style-".concat(mergedHashId) : '';
+  var cssText = useMemo(function () {
+    if (!mergedHashId) {
+      return '';
+    }
+    return styleToCssText(".".concat(mergedHashId), styleFn(token));
+  }, [mergedHashId, styleFn, token]);
+  useEffect(function () {
+    if (!mergedHashId || !cssText || typeof document === 'undefined') {
+      return undefined;
+    }
+    var styleTag = document.getElementById(styleId);
+    var nextUsage = (styleUsageMap.get(styleId) || 0) + 1;
+    styleUsageMap.set(styleId, nextUsage);
+    if (!styleTag) {
+      styleTag = document.createElement('style');
+      styleTag.id = styleId;
+      styleTag.setAttribute('data-x-web-pro-style', mergedHashId);
+      document.head.appendChild(styleTag);
+    }
+    styleTag.textContent = cssText;
+    return function () {
+      var currentUsage = (styleUsageMap.get(styleId) || 1) - 1;
+      if (currentUsage <= 0) {
+        var _styleTag;
+        styleUsageMap.delete(styleId);
+        (_styleTag = styleTag) === null || _styleTag === void 0 || (_styleTag = _styleTag.parentNode) === null || _styleTag === void 0 || _styleTag.removeChild(styleTag);
+        return;
+      }
+      styleUsageMap.set(styleId, currentUsage);
+    };
+  }, [cssText, mergedHashId, styleId]);
+  return {
+    wrapSSR: function wrapSSR(node) {
+      if (!mergedHashId) {
+        return node;
+      }
+      var className = [node.props.className, mergedHashId].filter(Boolean).join(' ');
+      return /*#__PURE__*/React.cloneElement(node, {
+        className: className
+      });
+    },
+    hashId: mergedHashId
+  };
+}

package/es/components/skeleton/index.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+export interface PageHeaderSkeletonProps {
+    active?: boolean;
+    className?: string;
+}
+export interface ListToolbarSkeletonProps {
+    active?: boolean;
+    className?: string;
+}
+export interface ListSkeletonItemProps {
+    active?: boolean;
+    className?: string;
+}
+export interface ListSkeletonProps {
+    active?: boolean;
+    itemCount?: number;
+    className?: string;
+}
+export interface ListPageSkeletonProps extends ListSkeletonProps {
+    pageHeader?: false;
+    statistic?: number | false;
+    actionButton?: React.ReactNode | false;
+    toolbar?: false;
+    list?: number | false;
+}
+export interface TableSkeletonProps {
+    active?: boolean;
+    rowCount?: number;
+    columnCount?: number;
+    className?: string;
+}
+export interface DescriptionsSkeletonProps {
+    active?: boolean;
+    column?: number;
+    className?: string;
+}
+export interface DescriptionsPageSkeletonProps extends DescriptionsSkeletonProps {
+    pageHeader?: false;
+    list?: false | number;
+}
+export interface ProSkeletonProps extends ListPageSkeletonProps, TableSkeletonProps, DescriptionsSkeletonProps {
+    type?: 'list' | 'result' | 'descriptions' | 'table' | 'pageHeader';
+    pageHeader?: false;
+    toolbar?: false;
+    statistic?: number | false;
+    actionButton?: React.ReactNode | false;
+    list?: number | false;
+}
+export declare const PageHeaderSkeleton: React.FC<PageHeaderSkeletonProps>;
+export declare const ListToolbarSkeleton: React.FC<ListToolbarSkeletonProps>;
+export declare const ListSkeletonItem: React.FC<ListSkeletonItemProps>;
+export declare const ListSkeleton: React.FC<ListSkeletonProps>;
+export declare const TableItemSkeleton: React.FC<TableSkeletonProps>;
+export declare const TableSkeleton: React.FC<TableSkeletonProps>;
+export declare const DescriptionsSkeleton: React.FC<DescriptionsSkeletonProps>;
+export declare const ProSkeleton: React.FC<ProSkeletonProps>;
+export declare const ListPageSkeleton: React.FC<ProSkeletonProps>;
+export declare const DescriptionsPageSkeleton: React.FC<ProSkeletonProps>;
+export declare const ResultPageSkeleton: React.FC<ProSkeletonProps>;
+export type { ListPageSkeletonProps as ProListPageSkeletonProps, DescriptionsPageSkeletonProps as ProDescriptionsPageSkeletonProps };
+export default ProSkeleton;