@pisell/materials 6.3.17 → 6.3.18

package/lib/components/pisellToast/index.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/components/pisellToast/index.tsx
 var pisellToast_exports = {};
 __export(pisellToast_exports, {
-  default: () => pisellToast_default
+  default: () => pisellToast_default,
+  useToast: () => import_squareToast.useToast
 });
 module.exports = __toCommonJS(pisellToast_exports);
 var import_react = __toESM(require("react"));
@@ -37,9 +38,13 @@ var import_utils = require("@pisell/utils");
 var import_pisellMessage = require("../pisellMessage");
 var import_iconfont = __toESM(require("../iconfont"));
 var import_index = require("./index.less");
+var import_squareToast = require("./squareToast");
 var PisellToast = (props) => {
   const { content, duration, showAction, actionText, onClose } = props;
   const key = (0, import_utils.getUniqueId)();
+  if (!import_pisellMessage.message) {
+    return alert(content);
+  }
   import_pisellMessage.message.open({
     key,
     content: /* @__PURE__ */ import_react.default.createElement("div", { className: "pisell-toast-content" }, /* @__PURE__ */ import_react.default.createElement("span", null, content), showAction && /* @__PURE__ */ import_react.default.createElement("span", { className: "pisell-toast-action" }, actionText), /* @__PURE__ */ import_react.default.createElement(
@@ -57,3 +62,7 @@ var PisellToast = (props) => {
   });
 };
 var pisellToast_default = PisellToast;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useToast
+});

package/lib/components/pisellToast/squareToast/index.d.ts

@@ -0,0 +1,15 @@
+import { clear, show, success, info, loading, fail, hide } from './methods';
+import './index.less';
+interface ToastInstance {
+    show: typeof show;
+    clear: typeof clear;
+    success: typeof success;
+    info: typeof info;
+    loading: typeof loading;
+    fail: typeof fail;
+    error: typeof fail;
+    hide: typeof hide;
+}
+declare const Toast: ToastInstance;
+export declare const useToast: () => ToastInstance;
+export default Toast;

package/lib/components/pisellToast/squareToast/index.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellToast/squareToast/index.tsx
+var squareToast_exports = {};
+__export(squareToast_exports, {
+  default: () => squareToast_default,
+  useToast: () => useToast
+});
+module.exports = __toCommonJS(squareToast_exports);
+var import_react = require("react");
+var import_methods = require("./methods");
+var import_index = require("./index.less");
+var Toast = {
+  show: import_methods.show,
+  clear: import_methods.clear,
+  success: import_methods.success,
+  info: import_methods.info,
+  loading: import_methods.loading,
+  fail: import_methods.fail,
+  error: import_methods.fail,
+  hide: import_methods.hide
+};
+var useToast = () => {
+  return (0, import_react.useMemo)(
+    () => ({
+      show: import_methods.show,
+      clear: import_methods.clear,
+      success: import_methods.success,
+      info: import_methods.info,
+      loading: import_methods.loading,
+      fail: import_methods.fail,
+      error: import_methods.fail,
+      hide: import_methods.hide
+    }),
+    []
+  );
+};
+var squareToast_default = Toast;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useToast
+});

package/lib/components/pisellToast/squareToast/index.less

@@ -0,0 +1,60 @@
+.pisell-square-toast-wrap {
+  pointer-events: none;
+}
+
+.pisell-square-toast-modal {
+  pointer-events: none;
+  user-select: none;
+  min-width: 190px;
+  min-height: 74px;
+
+  // Toast 容器
+  .pisell-square-toast {
+    min-width: 190px;
+    max-width: 201px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    padding: 32px 12px;
+    border-radius: 8px;
+    overflow: hidden;
+    background: rgba(0, 0, 0, 0.8);
+
+    .pisell-square-toast-icon-wrapper {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin-bottom: 11px;
+
+      .pisell-square-toast-icon {
+        font-size: 50px;
+        color: #ffffff;
+        width: 50px;
+        height: 50px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+
+        &-loading {
+          animation: fadenum 1s infinite linear;
+        }
+      }
+    }
+
+    // 内容区域
+    .pisell-square-toast-content {
+      font-size: 20px;
+      line-height: 1.5;
+      color: #ffffff;
+      text-align: center;
+    }
+  }
+}
+
+// loading 旋转动画
+@keyframes fadenum {
+  to {
+    transform: rotate(360deg);
+  }
+}

package/lib/components/pisellToast/squareToast/methods.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ToastProps } from './toast';
+interface ToastInstance {
+    close: () => void;
+}
+declare const show: (configOrContent: Partial<ToastProps> | React.ReactNode, duration?: number, afterClose?: () => void) => ToastInstance;
+declare const clear: () => void;
+declare const success: (content: React.ReactNode, duration?: number, afterClose?: () => void) => ToastInstance;
+declare const info: (content: React.ReactNode, duration?: number, afterClose?: () => void) => ToastInstance;
+declare const loading: (content: React.ReactNode, duration?: number, afterClose?: () => void) => ToastInstance;
+declare const fail: (content: React.ReactNode, duration?: number, afterClose?: () => void) => ToastInstance;
+declare const hide: () => void;
+export { show, clear, success, info, loading, fail, hide };

package/lib/components/pisellToast/squareToast/methods.js

@@ -0,0 +1,150 @@
+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/components/pisellToast/squareToast/methods.tsx
+var methods_exports = {};
+__export(methods_exports, {
+  clear: () => clear,
+  fail: () => fail,
+  hide: () => hide,
+  info: () => info,
+  loading: () => loading,
+  show: () => show,
+  success: () => success
+});
+module.exports = __toCommonJS(methods_exports);
+var import_react = __toESM(require("react"));
+var import_toast = __toESM(require("./toast"));
+var import_renderImperatively = require("./renderImperatively");
+var currentHandler = null;
+var currentTimeout = null;
+var defaultProps = {
+  duration: 2e3,
+  mask: false,
+  icon: "info"
+};
+function mergeProps(a, b) {
+  const filteredB = Object.keys(b).reduce((acc, key) => {
+    if (b[key] !== void 0) {
+      acc[key] = b[key];
+    }
+    return acc;
+  }, {});
+  return {
+    ...a,
+    ...filteredB
+  };
+}
+var show = (configOrContent, duration, afterClose) => {
+  var _a;
+  let props;
+  if (typeof configOrContent === "string" || import_react.default.isValidElement(configOrContent)) {
+    props = mergeProps(defaultProps, {
+      content: configOrContent,
+      ...duration !== void 0 && { duration },
+      ...afterClose !== void 0 && { afterClose }
+    });
+  } else {
+    props = mergeProps(defaultProps, configOrContent || {});
+  }
+  const element = /* @__PURE__ */ import_react.default.createElement(
+    import_toast.default,
+    {
+      ...props,
+      onCancel: () => {
+        currentHandler = null;
+      }
+    }
+  );
+  if (currentHandler) {
+    if ((_a = currentHandler.isRendered) == null ? void 0 : _a.call(currentHandler)) {
+      currentHandler.replace(element);
+    } else {
+      currentHandler.close();
+      currentHandler = (0, import_renderImperatively.renderImperatively)(element);
+    }
+  } else {
+    currentHandler = (0, import_renderImperatively.renderImperatively)(element);
+  }
+  if (currentTimeout) {
+    window.clearTimeout(currentTimeout);
+  }
+  if (props.duration !== 0) {
+    currentTimeout = window.setTimeout(() => {
+      clear();
+    }, props.duration);
+  }
+  const instance = {
+    close: () => {
+      if (currentHandler) {
+        currentHandler.close();
+        currentHandler = null;
+      }
+      if (currentTimeout) {
+        window.clearTimeout(currentTimeout);
+        currentTimeout = null;
+      }
+    }
+  };
+  return instance;
+};
+var clear = () => {
+  if (currentHandler) {
+    currentHandler.close();
+    currentHandler = null;
+  }
+  if (currentTimeout) {
+    window.clearTimeout(currentTimeout);
+    currentTimeout = null;
+  }
+};
+var success = (content, duration, afterClose) => {
+  return show({ content, icon: "success", duration, afterClose });
+};
+var info = (content, duration, afterClose) => {
+  return show({ content, icon: "info", duration, afterClose });
+};
+var loading = (content, duration, afterClose) => {
+  return show({ content, icon: "loading", duration, afterClose });
+};
+var fail = (content, duration, afterClose) => {
+  return show({ content, icon: "error", duration, afterClose });
+};
+var hide = () => {
+  clear();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clear,
+  fail,
+  hide,
+  info,
+  loading,
+  show,
+  success
+});

package/lib/components/pisellToast/squareToast/renderImperatively.d.ts

@@ -0,0 +1,28 @@
+import type { ReactElement } from 'react';
+import type { Root } from 'react-dom/client';
+import React from 'react';
+declare type ImperativeProps = {
+    open?: boolean;
+    onCancel?: () => void;
+    afterClose?: () => void;
+};
+declare type TargetElement = ReactElement<ImperativeProps>;
+export declare type ImperativeHandler = {
+    close: () => void;
+    replace: (element: TargetElement) => void;
+    isRendered?: () => boolean;
+};
+export declare type UnmountType = () => Promise<void>;
+export declare type RenderType = (node: React.ReactElement, container: Element | DocumentFragment) => UnmountType;
+declare const MARK = "__pisell_react_root__";
+declare type ContainerType = (Element | DocumentFragment) & {
+    [MARK]?: Root;
+};
+export declare function render(node: React.ReactElement, container: ContainerType): void;
+export declare function unmount(container: ContainerType): Promise<void>;
+/**
+ * @deprecated 设置 React 渲染函数以兼容使用。
+ */
+export declare function unstableSetRender(render?: RenderType): RenderType;
+export declare function renderImperatively(element: TargetElement): ImperativeHandler;
+export {};

package/lib/components/pisellToast/squareToast/renderImperatively.js

@@ -0,0 +1,162 @@
+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/components/pisellToast/squareToast/renderImperatively.tsx
+var renderImperatively_exports = {};
+__export(renderImperatively_exports, {
+  render: () => render2,
+  renderImperatively: () => renderImperatively,
+  unmount: () => unmount,
+  unstableSetRender: () => unstableSetRender
+});
+module.exports = __toCommonJS(renderImperatively_exports);
+var ReactDOM = __toESM(require("react-dom"));
+var import_react = __toESM(require("react"));
+var MARK = "__pisell_react_root__";
+function render2(node, container) {
+  const root = container[MARK];
+  if (root) {
+    root.render(node);
+    return;
+  }
+  const ReactMajorVersion = parseInt(import_react.default.version.split(".")[0], 10);
+  const isReact18OrNewer = ReactMajorVersion >= 18;
+  const fallbackCreateRoot = ReactDOM.createRoot;
+  if (isReact18OrNewer && fallbackCreateRoot) {
+    const root2 = fallbackCreateRoot(container);
+    root2.render(node);
+    container[MARK] = root2;
+    return;
+  }
+  if (ReactMajorVersion >= 19) {
+    console.error(
+      "[pisellToast] React 19+ requires `createRoot`. Please call `setCreateRoot(createRoot)` at your app entry."
+    );
+  }
+  ReactDOM.render(node, container);
+}
+async function unmount(container) {
+  return Promise.resolve().then(() => {
+    var _a;
+    if (container[MARK]) {
+      (_a = container[MARK]) == null ? void 0 : _a.unmount();
+      delete container[MARK];
+    } else {
+      ReactDOM.unmountComponentAtNode(container);
+    }
+  });
+}
+var defaultReactRender = (node, container) => {
+  render2(node, container);
+  return () => {
+    return unmount(container);
+  };
+};
+var unstableRender = defaultReactRender;
+function unstableSetRender(render3) {
+  if (render3) {
+    unstableRender = render3;
+  }
+  return unstableRender;
+}
+var sharedContainer = null;
+function renderToBody(element) {
+  if (!sharedContainer) {
+    sharedContainer = document.createElement("div");
+    document.body.appendChild(sharedContainer);
+  }
+  const container = sharedContainer;
+  return unstableSetRender()(element, container);
+}
+function renderImperatively(element) {
+  const Wrapper = import_react.default.forwardRef((_, ref) => {
+    const [open, setOpen] = (0, import_react.useState)(false);
+    const closedRef = (0, import_react.useRef)(false);
+    const [elementToRender, setElementToRender] = (0, import_react.useState)(element);
+    const keyRef = (0, import_react.useRef)(0);
+    (0, import_react.useEffect)(() => {
+      if (!closedRef.current) {
+        setOpen(true);
+      } else {
+        afterClose();
+      }
+    }, []);
+    function onCancel() {
+      var _a, _b;
+      closedRef.current = true;
+      setOpen(false);
+      (_b = (_a = elementToRender.props).onCancel) == null ? void 0 : _b.call(_a);
+    }
+    function afterClose() {
+      var _a, _b;
+      unmount2();
+      (_b = (_a = elementToRender.props).afterClose) == null ? void 0 : _b.call(_a);
+    }
+    (0, import_react.useImperativeHandle)(ref, () => ({
+      close: onCancel,
+      replace: (element2) => {
+        var _a, _b;
+        keyRef.current++;
+        (_b = (_a = elementToRender.props).afterClose) == null ? void 0 : _b.call(_a);
+        setElementToRender(element2);
+      }
+    }));
+    return import_react.default.cloneElement(elementToRender, {
+      ...elementToRender.props,
+      key: keyRef.current,
+      open,
+      onCancel,
+      afterClose
+    });
+  });
+  const wrapperRef = import_react.default.createRef();
+  const unmount2 = renderToBody(/* @__PURE__ */ import_react.default.createElement(Wrapper, { ref: wrapperRef }));
+  return {
+    close: async () => {
+      var _a, _b, _c;
+      if (!wrapperRef.current) {
+        unmount2();
+        (_b = (_a = element.props).afterClose) == null ? void 0 : _b.call(_a);
+      } else {
+        (_c = wrapperRef.current) == null ? void 0 : _c.close();
+      }
+    },
+    replace: (element2) => {
+      var _a;
+      (_a = wrapperRef.current) == null ? void 0 : _a.replace(element2);
+    },
+    isRendered: () => !!wrapperRef.current
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render,
+  renderImperatively,
+  unmount,
+  unstableSetRender
+});

package/lib/components/pisellToast/squareToast/toast.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import './index.less';
+export declare type ToastType = 'success' | 'error' | 'warning' | 'info' | 'loading';
+export interface ToastProps {
+    /** Toast 类型 */
+    icon?: ToastType | React.ReactNode;
+    /** 显示的内容，支持文本或 React 节点 */
+    content: React.ReactNode;
+    /** 是否显示 */
+    open?: boolean;
+    /** 自动关闭时间，单位毫秒，0 表示不自动关闭 */
+    duration?: number;
+    /** 关闭 */
+    onCancel?: () => void;
+    /** 关闭后回调 */
+    afterClose?: () => void;
+    /** 自定义样式类名 */
+    className?: string;
+    /** 自定义样式 */
+    style?: React.CSSProperties;
+    /** 是否显示遮罩 */
+    mask?: boolean;
+}
+declare const Toast: React.FC<ToastProps>;
+export default Toast;

package/lib/components/pisellToast/squareToast/toast.js

@@ -0,0 +1,88 @@
+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/components/pisellToast/squareToast/toast.tsx
+var toast_exports = {};
+__export(toast_exports, {
+  default: () => toast_default
+});
+module.exports = __toCommonJS(toast_exports);
+var import_react = __toESM(require("react"));
+var import_modal = __toESM(require("../../modal"));
+var import_icon = __toESM(require("../../icon"));
+var import_classnames = __toESM(require("classnames"));
+var import_index = require("./index.less");
+var icons = {
+  info: "",
+  success: "iconchenggong-1-01",
+  error: "icon-warning",
+  warning: "icon-warning",
+  loading: "icon-loading",
+  fail: "icon-warning"
+};
+var Toast = ({
+  content,
+  open,
+  icon,
+  className,
+  ...rest
+}) => {
+  const iconElement = (0, import_react.useMemo)(() => {
+    if (icon === null || icon === void 0) return null;
+    if (typeof icon === "string" && icon in icons) {
+      if (!icons[icon]) return null;
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_icon.default,
+        {
+          type: icons[icon],
+          className: `pisell-square-toast-icon pisell-square-toast-icon-${icon}`
+        }
+      );
+    }
+    return icon;
+  }, [icon]);
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_modal.default,
+    {
+      open,
+      footer: null,
+      closable: false,
+      centered: true,
+      maskTransitionName: "",
+      transitionName: "",
+      width: "unset",
+      wrapClassName: "pisell-square-toast-wrap",
+      className: (0, import_classnames.default)("pisell-square-toast-modal", className),
+      bodyStyle: { padding: 0 },
+      destroyOnClose: true,
+      modalRender: () => /* @__PURE__ */ import_react.default.createElement("div", { className: `pisell-square-toast` }, iconElement && /* @__PURE__ */ import_react.default.createElement("div", { className: "pisell-square-toast-icon-wrapper" }, iconElement), /* @__PURE__ */ import_react.default.createElement("div", { className: "pisell-square-toast-content" }, content)),
+      ...rest
+    }
+  );
+};
+var toast_default = Toast;