@qsxy/element-plus-react 1.0.0-next.1

package/dist/InputNumber/InputNumber.js

@@ -0,0 +1,231 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/InputNumber/InputNumber.tsx
+var InputNumber_exports = {};
+__export(InputNumber_exports, {
+  default: () => InputNumber_default
+});
+module.exports = __toCommonJS(InputNumber_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_max = __toESM(require("lodash/max"));
+var import_min = __toESM(require("lodash/min"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_toFinite = __toESM(require("lodash/toFinite"));
+var import_react = __toESM(require("react"));
+var import_ConfigProvider = require("../ConfigProvider");
+var import_Icon = require("../Icon");
+var import_Input = require("../Input");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var InputNumber = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    name,
+    max: _maxProp,
+    min: _minProp,
+    step,
+    precision,
+    onChange,
+    classPrefix = "input-number",
+    prefix,
+    suffix,
+    prepend,
+    append,
+    placeholder,
+    warning,
+    error,
+    maxLength,
+    minLength,
+    ...rest
+  } = props;
+  const { b, e, m, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [htmlInputProps] = (0, import_hooks.partitionHTMLProps)(rest);
+  const [value, setValue] = (0, import_hooks.useControlled)(props.value, props.defaultValue);
+  const disabled = (0, import_hooks.useDisabled)(props.disabled);
+  const size = (0, import_hooks.useSize)(props.size);
+  const { inputNumber } = (0, import_react.useContext)(import_ConfigProvider.ConfigProvider);
+  const valueRef = (0, import_react.useRef)(value);
+  const containerRef = (0, import_react.useRef)(null);
+  const inputRef = (0, import_react.useRef)(null);
+  const isCtrlKey = (0, import_react.useRef)(false);
+  const controlsPositionRight = (0, import_react.useMemo)(() => {
+    return props.controlsPositionRight || (inputNumber == null ? void 0 : inputNumber.controlsPositionRight) || (0, import_Util.isNotEmpty)(prefix) || (0, import_Util.isNotEmpty)(suffix) || (0, import_Util.isNotEmpty)(prepend) || (0, import_Util.isNotEmpty)(append);
+  }, [append, inputNumber == null ? void 0 : inputNumber.controlsPositionRight, prefix, prepend, props.controlsPositionRight, suffix]);
+  const maxProp = (0, import_react.useMemo)(() => _maxProp ?? (inputNumber == null ? void 0 : inputNumber.max) ?? Infinity, [_maxProp, inputNumber == null ? void 0 : inputNumber.max]);
+  const minProp = (0, import_react.useMemo)(() => _minProp ?? (inputNumber == null ? void 0 : inputNumber.min) ?? -Infinity, [_minProp, inputNumber == null ? void 0 : inputNumber.min]);
+  const increase = (0, import_react.useCallback)(() => {
+    if (disabled) {
+      return;
+    }
+    const increaseValue = (0, import_min.default)([(0, import_Util.floatAdd)((0, import_toFinite.default)(value), step), maxProp]);
+    const increaseOldValue = value;
+    const formatVal = (0, import_Util.formatNumber)(increaseValue, precision);
+    setValue(formatVal);
+    onChange == null ? void 0 : onChange((0, import_toFinite.default)(formatVal), increaseOldValue);
+  }, [disabled, value, step, maxProp, precision, setValue, onChange]);
+  const decrease = (0, import_react.useCallback)(() => {
+    if (disabled) {
+      return;
+    }
+    const decreaseValue = (0, import_max.default)([(0, import_Util.floatSub)((0, import_toFinite.default)(value), step), minProp]);
+    const decreaseOldValue = value;
+    const formatVal = (0, import_Util.formatNumber)(decreaseValue, precision);
+    setValue(formatVal);
+    onChange == null ? void 0 : onChange((0, import_toFinite.default)(formatVal), decreaseOldValue);
+  }, [disabled, value, step, minProp, precision, setValue, onChange]);
+  const onInput = (0, import_react.useCallback)(
+    (inputVal) => {
+      inputVal = inputVal.split("").filter((item, index) => {
+        if (item === "-" && index > 0) {
+          return false;
+        }
+        return true;
+      }).join("");
+      setValue(inputVal);
+      valueRef.current = inputVal;
+      if (!inputVal.endsWith(".") && !inputVal.endsWith("0")) {
+        const _inputVal = (0, import_Util.isEmpty)(inputVal) ? "" : (0, import_toFinite.default)(inputVal);
+        setValue(_inputVal);
+        onChange == null ? void 0 : onChange(_inputVal);
+      }
+      inputRef.current.input.current.value = (0, import_Util.isEmpty)(inputVal) ? "" : inputVal;
+    },
+    [onChange, setValue]
+  );
+  const onBlur = (0, import_react.useCallback)(() => {
+    if ((0, import_Util.isEmpty)(valueRef.current)) {
+      setValue("");
+      onChange == null ? void 0 : onChange("");
+      valueRef.current = "";
+      inputRef.current.input.current.value = "";
+      return;
+    }
+    const inputOldValue = value;
+    const val = (0, import_toFinite.default)(valueRef.current);
+    const formatVal = (0, import_Util.formatNumber)(val, precision);
+    if (val > maxProp) {
+      setValue(maxProp);
+      onChange == null ? void 0 : onChange(maxProp, inputOldValue);
+      inputRef.current.input.current.value = maxProp + "";
+      return;
+    } else if (val < minProp) {
+      setValue(minProp);
+      onChange == null ? void 0 : onChange(minProp, inputOldValue);
+      inputRef.current.input.current.value = minProp + "";
+      return;
+    }
+    setValue(formatVal);
+    onChange == null ? void 0 : onChange((0, import_toFinite.default)(formatVal), inputOldValue);
+    inputRef.current.input.current.value = formatVal;
+  }, [maxProp, minProp, onChange, precision, setValue, value]);
+  (0, import_react.useEffect)(() => {
+    valueRef.current = value;
+  }, [value]);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    get ref() {
+      return containerRef;
+    },
+    get input() {
+      return inputRef;
+    },
+    getValue: () => (0, import_toFinite.default)(value),
+    focus: inputRef.current.focus,
+    blur: inputRef.current.blur
+  }));
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), m({ [size]: size }), is({ "controls-right": controlsPositionRight }), props.className), style: props.style, ref: containerRef }, /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`decrease`, is({ disabled: disabled || value == minProp })), onClick: decrease }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: controlsPositionRight ? "fal" : "far", name: controlsPositionRight ? "angle-down" : "minus" })), /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`increase`, is({ disabled: disabled || value == maxProp })), onClick: increase }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: controlsPositionRight ? "fal" : "far", name: controlsPositionRight ? "angle-up" : "plus" })), /* @__PURE__ */ import_react.default.createElement(
+    import_Input.Input,
+    {
+      placeholder,
+      prefix,
+      suffix,
+      name,
+      value,
+      disabled,
+      readOnly: props.readOnly,
+      size,
+      error,
+      warning,
+      clearable: false,
+      onBlur,
+      onChange: onInput,
+      maxLength,
+      minLength: maxLength,
+      onKeyDown: (0, import_react.useCallback)((event) => {
+        if (event.ctrlKey) {
+          isCtrlKey.current = true;
+        }
+        if (isCtrlKey.current) {
+          if (!["c", "v", "x"].includes(event.key)) {
+            event.preventDefault();
+          }
+        } else if (!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-", ".", "ArrowLeft", "ArrowRight", "Backspace", "Delete"].includes(event.key)) {
+          event.preventDefault();
+        }
+        const val = valueRef.current;
+        if ((0, import_Util.isNotEmpty)(val)) {
+          if (val.toString().indexOf(".") > -1 && event.key === ".") {
+            event.preventDefault();
+          }
+          if (val.toString().indexOf("-") > -1 && event.key === "-") {
+            event.preventDefault();
+          }
+        }
+      }, []),
+      onKeyUp: (0, import_react.useCallback)(() => {
+        isCtrlKey.current = false;
+      }, []),
+      ref: inputRef,
+      ...(0, import_omit.default)(htmlInputProps, [
+        "disabled",
+        "size",
+        "onInput",
+        "onKeyDown",
+        "onKeyUp",
+        "size",
+        "onChange",
+        "style",
+        "className",
+        "type",
+        "name",
+        "prefix",
+        "readOnly",
+        "maxLength",
+        "minLength"
+      ])
+    }
+  ));
+});
+InputNumber.defaultProps = {
+  step: 1,
+  precision: 0,
+  max: Infinity,
+  min: -Infinity,
+  placeholder: "请输入"
+};
+InputNumber.displayName = "ElInputNumber";
+var InputNumber_default = (0, import_react.memo)(InputNumber);

package/dist/InputNumber/index.d.ts

@@ -0,0 +1,2 @@
+export { default as InputNumber } from './InputNumber';
+export type { InputNumberProps, InputNumberRef } from './typings';

package/dist/InputNumber/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/InputNumber/index.ts
+var InputNumber_exports = {};
+__export(InputNumber_exports, {
+  InputNumber: () => import_InputNumber.default
+});
+module.exports = __toCommonJS(InputNumber_exports);
+var import_InputNumber = __toESM(require("./InputNumber"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InputNumber
+});

package/dist/InputNumber/typings.d.ts

@@ -0,0 +1,31 @@
+import React, { Ref } from 'react';
+import { InputRef } from '../Input';
+import { BaseProps, FormControlBaseProps, NativeProps } from '../types/common';
+export type LiteralUnion<T extends U, U> = T | (U & {});
+export type ValueType = number | string;
+export interface InputNumberProps<V = ValueType> extends Omit<FormControlBaseProps<V>, 'onChange'>, BaseProps<HTMLDivElement>, NativeProps, Omit<React.AllHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'size' | 'prefix' | 'type' | 'onInput' | 'onChange' | 'style' | 'value' | 'ref' | 'className' | 'readOnly' | 'disabled' | 'name' | 'children'> {
+    max?: number;
+    min?: number;
+    step?: number;
+    stepStrictly?: boolean;
+    precision?: number;
+    controlsPositionRight?: boolean;
+    placeholder?: string;
+    onChange?: (currentValue: number | string, oldValue?: number | string) => void;
+    prefixCls?: string;
+    error?: boolean;
+    warning?: boolean;
+    prefix?: React.ReactElement<any> | string | number;
+    suffix?: React.ReactElement<any> | string | number;
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+    maxLength?: number;
+    minLength?: number;
+}
+export interface InputNumberRef {
+    ref: Ref<HTMLDivElement>;
+    input: Ref<InputRef>;
+    getValue: () => number;
+    focus: () => void;
+    blur: () => void;
+}

package/dist/InputNumber/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/InputNumber/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Link/Link.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { LinkProps } from './typings';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<any>>>;
+export default _default;

package/dist/Link/Link.js

@@ -0,0 +1,64 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Link/Link.tsx
+var Link_exports = {};
+__export(Link_exports, {
+  default: () => Link_default
+});
+module.exports = __toCommonJS(Link_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_hooks = require("../hooks");
+var Link = (0, import_react.forwardRef)((props, ref) => {
+  const { type, underline, disabled, className, style, classPrefix = "link", onClick, icon, ...rest } = props;
+  const { b, m, is } = (0, import_hooks.useClassNames)(classPrefix);
+  return /* @__PURE__ */ import_react.default.createElement(
+    "a",
+    {
+      ref,
+      className: (0, import_classnames.default)(b(), m(type), is({ underline, disabled }), className),
+      style,
+      onClick: (event) => {
+        if (disabled) {
+          return;
+        }
+        onClick == null ? void 0 : onClick.call(void 0, event);
+      },
+      ...rest
+    },
+    icon && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: icon }),
+    props.children
+  );
+});
+Link.displayName = "Link";
+Link.defaultProps = {
+  type: "default"
+};
+var Link_default = (0, import_react.memo)(Link);

package/dist/Link/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Link } from './Link';
+export type { LinkProps } from './typings';

package/dist/Link/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Link/index.ts
+var Link_exports = {};
+__export(Link_exports, {
+  Link: () => import_Link.default
+});
+module.exports = __toCommonJS(Link_exports);
+var import_Link = __toESM(require("./Link"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Link
+});

package/dist/Link/typings.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { IconName } from '../Icon';
+import { BaseProps, NativeProps, TypeAttributes } from '../types/common';
+export type LinkType = TypeAttributes.Appearance;
+export interface LinkProps extends BaseProps, NativeProps, Omit<React.AllHTMLAttributes<HTMLAnchorElement>, 'type' | 'style' | 'children'> {
+    href?: string;
+    type?: LinkType;
+    underline?: boolean;
+    disabled?: boolean;
+    icon?: IconName;
+}

package/dist/Link/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Link/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Loading/Loading.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { LoadingProps, LoadingService } from './typings';
+declare const Loading: CompInterface;
+interface CompInterface extends FC<LoadingProps> {
+    displayName?: string;
+    defaultProps?: Partial<LoadingProps>;
+    service: LoadingService;
+}
+export default Loading;

package/dist/Loading/Loading.js

@@ -0,0 +1,70 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Loading/Loading.tsx
+var Loading_exports = {};
+__export(Loading_exports, {
+  default: () => Loading_default
+});
+module.exports = __toCommonJS(Loading_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_react_dom = require("react-dom");
+var import_client = require("react-dom/client");
+var import_Icon = require("../Icon");
+var import_Transition = require("../Transition");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var Main = (props) => {
+  const { visible, text, fullscreen, spinner, background } = props;
+  const { b, is } = (0, import_hooks.useClassNames)("loading");
+  return /* @__PURE__ */ import_react.default.createElement(import_Transition.Transition, { name: "loading-fade", visible }, /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b`mask`, is({ fullscreen }), props.className), style: { ...props.style, background, zIndex: import_Util.PopupManager.nextZIndex() } }, /* @__PURE__ */ import_react.default.createElement("div", { className: b`spinner` }, spinner ? /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: spinner, spin: true }) : /* @__PURE__ */ import_react.default.createElement("svg", { className: "circular", viewBox: "25 25 50 50" }, /* @__PURE__ */ import_react.default.createElement("circle", { className: "path", cx: "50", cy: "50", r: "20", fill: "none" })), text && /* @__PURE__ */ import_react.default.createElement("p", { className: b`text` }, text))));
+};
+var service = (props = {}) => {
+  const { target = { current: document.body } } = props;
+  const root = (0, import_client.createRoot)(document.body);
+  root.render((0, import_react_dom.createPortal)(/* @__PURE__ */ import_react.default.createElement(Main, { ...props, visible: true }), target.current));
+  return {
+    close: () => {
+      root.unmount();
+    }
+  };
+};
+var Loading = (props) => {
+  const { target, visible } = props;
+  if (target == null ? void 0 : target.current) {
+    return (0, import_react_dom.createPortal)(/* @__PURE__ */ import_react.default.createElement(Main, { ...props, visible }), target.current);
+  }
+  return /* @__PURE__ */ import_react.default.createElement(Main, { ...props, visible });
+};
+Loading.defaultProps = {
+  fullscreen: true
+};
+Loading.service = service;
+Loading.displayName = "Loading";
+var Loading_default = Loading;

package/dist/Loading/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Loading } from './Loading';
+export type { LoadingProps } from './typings';

package/dist/Loading/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Loading/index.ts
+var Loading_exports = {};
+__export(Loading_exports, {
+  Loading: () => import_Loading.default
+});
+module.exports = __toCommonJS(Loading_exports);
+var import_Loading = __toESM(require("./Loading"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Loading
+});

package/dist/Loading/typings.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+import { IconName } from '../Icon';
+import { BaseProps, NativeProps } from '../types/common';
+export interface LoadingProps extends BaseProps, NativeProps {
+    target?: RefObject<HTMLElement>;
+    visible?: boolean;
+    fullscreen?: boolean;
+    lock?: boolean;
+    text?: string;
+    spinner?: IconName;
+    background?: string;
+}
+export type LoadingService = (props?: LoadingProps) => {
+    close: () => void;
+};

package/dist/Loading/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Loading/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Message/Main.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { MessageProps, MessageRef } from './typings';
+export declare class Main {
+    ref: React.RefObject<MessageRef>;
+    constructor(props: MessageProps);
+    render(props: MessageProps): void;
+}
+export default Main;