zartui 0.1.113 → 3.0.1

package/lib/tabs/utils.js

@@ -1,53 +1,56 @@
-"use strict";
-
-exports.__esModule = true;
-exports.scrollLeftTo = scrollLeftTo;
-exports.scrollTopTo = scrollTopTo;
-
-var _raf = require("../utils/dom/raf");
-
-var _scroll = require("../utils/dom/scroll");
-
-var scrollLeftRafId;
-
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  scrollLeftTo: () => scrollLeftTo,
+  scrollTopTo: () => scrollTopTo
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_use = require("@zartui/use");
+var import_utils = require("../utils");
 function scrollLeftTo(scroller, to, duration) {
-  (0, _raf.cancelRaf)(scrollLeftRafId);
-  var count = 0;
-  var from = scroller.scrollLeft;
-  var frames = duration === 0 ? 1 : Math.round(duration * 1000 / 16);
-
+  let count = 0;
+  const from = scroller.scrollLeft;
+  const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
   function animate() {
     scroller.scrollLeft += (to - from) / frames;
-
     if (++count < frames) {
-      scrollLeftRafId = (0, _raf.raf)(animate);
+      (0, import_use.raf)(animate);
     }
   }
-
   animate();
 }
-
 function scrollTopTo(scroller, to, duration, callback) {
-  var current = (0, _scroll.getScrollTop)(scroller);
-  var isDown = current < to;
-  var frames = duration === 0 ? 1 : Math.round(duration * 1000 / 16);
-  var step = (to - current) / frames;
-
+  let current = (0, import_utils.getScrollTop)(scroller);
+  const isDown = current < to;
+  const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
+  const step = (to - current) / frames;
   function animate() {
     current += step;
-
     if (isDown && current > to || !isDown && current < to) {
       current = to;
     }
-
-    (0, _scroll.setScrollTop)(scroller, current);
-
+    (0, import_utils.setScrollTop)(scroller, current);
     if (isDown && current < to || !isDown && current > to) {
-      (0, _raf.raf)(animate);
+      (0, import_use.raf)(animate);
     } else if (callback) {
-      (0, _raf.raf)(callback);
+      (0, import_use.raf)(callback);
     }
   }
-
   animate();
-}
+}

package/lib/toast/Toast.d.ts

@@ -0,0 +1,112 @@
+import { PropType, CSSProperties, ExtractPropTypes } from 'vue';
+import { LoadingType } from '../loading';
+import type { ToastType, ToastPosition } from './types';
+declare const toastProps: {
+    icon: StringConstructor;
+    show: BooleanConstructor;
+    type: {
+        type: PropType<ToastType>;
+        default: ToastType;
+    };
+    overlay: BooleanConstructor;
+    message: (NumberConstructor | StringConstructor)[];
+    iconSize: (NumberConstructor | StringConstructor)[];
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<ToastPosition>;
+        default: ToastPosition;
+    };
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
+    className: PropType<unknown>;
+    iconPrefix: StringConstructor;
+    transition: {
+        type: PropType<string>;
+        default: string;
+    };
+    loadingType: PropType<LoadingType>;
+    forbidClick: BooleanConstructor;
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    closeOnClick: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+};
+export declare type ToastProps = ExtractPropTypes<typeof toastProps>;
+declare const _default: import("vue").DefineComponent<{
+    icon: StringConstructor;
+    show: BooleanConstructor;
+    type: {
+        type: PropType<ToastType>;
+        default: ToastType;
+    };
+    overlay: BooleanConstructor;
+    message: (NumberConstructor | StringConstructor)[];
+    iconSize: (NumberConstructor | StringConstructor)[];
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<ToastPosition>;
+        default: ToastPosition;
+    };
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
+    className: PropType<unknown>;
+    iconPrefix: StringConstructor;
+    transition: {
+        type: PropType<string>;
+        default: string;
+    };
+    loadingType: PropType<LoadingType>;
+    forbidClick: BooleanConstructor;
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    closeOnClick: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:show"[], "update:show", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    icon: StringConstructor;
+    show: BooleanConstructor;
+    type: {
+        type: PropType<ToastType>;
+        default: ToastType;
+    };
+    overlay: BooleanConstructor;
+    message: (NumberConstructor | StringConstructor)[];
+    iconSize: (NumberConstructor | StringConstructor)[];
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<ToastPosition>;
+        default: ToastPosition;
+    };
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
+    className: PropType<unknown>;
+    iconPrefix: StringConstructor;
+    transition: {
+        type: PropType<string>;
+        default: string;
+    };
+    loadingType: PropType<LoadingType>;
+    forbidClick: BooleanConstructor;
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    closeOnClick: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+}>> & {
+    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+}, {
+    type: ToastType;
+    position: ToastPosition;
+    overlay: boolean;
+    show: boolean;
+    duration: number;
+    closeOnClickOverlay: boolean;
+    transition: string;
+    forbidClick: boolean;
+    closeOnClick: boolean;
+}>;
+export default _default;

package/lib/toast/Toast.js

@@ -1,183 +1,138 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _utils = require("../utils");
-
-var _lockClick = require("./lock-click");
-
-var _popup = require("../mixins/popup");
-
-var _icon = _interopRequireDefault(require("../icon"));
-
-var _loading = _interopRequireDefault(require("../loading"));
-
-var _SuccessIcon = _interopRequireDefault(require("./svg/SuccessIcon"));
-
-var _WarnIcon = _interopRequireDefault(require("./svg/WarnIcon"));
-
-// Utils
-// Mixins
-// Components
-var _createNamespace = (0, _utils.createNamespace)('toast'),
-    createComponent = _createNamespace[0],
-    bem = _createNamespace[1];
-
-var _default = createComponent({
-  mixins: [(0, _popup.PopupMixin)()],
-  props: {
-    icon: String,
-    className: null,
-    iconPrefix: String,
-    loadingType: String,
-    forbidClick: Boolean,
-    closeOnClick: Boolean,
-    message: [Number, String],
-    type: {
-      type: String,
-      default: 'text'
-    },
-    position: {
-      type: String,
-      default: 'middle'
-    },
-    transition: {
-      type: String,
-      default: 'zt-fade'
-    },
-    lockScroll: {
-      type: Boolean,
-      default: false
-    }
-  },
-  data: function data() {
-    return {
-      clickable: false
-    };
-  },
-  mounted: function mounted() {
-    this.toggleClickable();
-  },
-  destroyed: function destroyed() {
-    this.toggleClickable();
-  },
-  watch: {
-    value: 'toggleClickable',
-    forbidClick: 'toggleClickable'
-  },
-  methods: {
-    onClick: function onClick() {
-      if (this.closeOnClick) {
-        this.close();
-      }
-    },
-    toggleClickable: function toggleClickable() {
-      var clickable = this.value && this.forbidClick;
-
-      if (this.clickable !== clickable) {
-        this.clickable = clickable;
-        (0, _lockClick.lockClick)(clickable);
-      }
-    },
-
-    /* istanbul ignore next */
-    onAfterEnter: function onAfterEnter() {
-      this.$emit('opened');
-
-      if (this.onOpened) {
-        this.onOpened();
-      }
-    },
-    onAfterLeave: function onAfterLeave() {
-      this.$emit('closed');
-    },
-    genIcon: function genIcon() {
-      var h = this.$createElement;
-      var icon = this.icon,
-          type = this.type,
-          iconPrefix = this.iconPrefix,
-          loadingType = this.loadingType;
-
-      if (icon) {
-        return h(_icon.default, {
-          "class": bem('icon'),
-          "attrs": {
-            "classPrefix": iconPrefix,
-            "name": icon || type
-          }
-        });
-      }
-
-      if (type === 'success') {
-        return h(_SuccessIcon.default, {
-          "class": bem('success')
-        });
-      }
-
-      if (type === 'fail') {
-        return h(_WarnIcon.default, {
-          "class": bem('fail')
-        });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_vue2 = require("vue");
+var import_utils = require("../utils");
+var import_lock_click = require("./lock-click");
+var import_icon = require("../icon");
+var import_popup = require("../popup");
+var import_loading = require("../loading");
+const [name, bem] = (0, import_utils.createNamespace)("toast");
+const popupInheritProps = ["show", "overlay", "teleport", "transition", "overlayClass", "overlayStyle", "closeOnClickOverlay"];
+const toastProps = {
+  icon: String,
+  show: Boolean,
+  type: (0, import_utils.makeStringProp)("text"),
+  overlay: Boolean,
+  message: import_utils.numericProp,
+  iconSize: import_utils.numericProp,
+  duration: (0, import_utils.makeNumberProp)(2e3),
+  position: (0, import_utils.makeStringProp)("middle"),
+  teleport: [String, Object],
+  className: import_utils.unknownProp,
+  iconPrefix: String,
+  transition: (0, import_utils.makeStringProp)("zt-fade"),
+  loadingType: String,
+  forbidClick: Boolean,
+  overlayClass: import_utils.unknownProp,
+  overlayStyle: Object,
+  closeOnClick: Boolean,
+  closeOnClickOverlay: Boolean
+};
+var stdin_default = (0, import_vue2.defineComponent)({
+  name,
+  props: toastProps,
+  emits: ["update:show"],
+  setup(props, {
+    emit
+  }) {
+    let timer;
+    let clickable = false;
+    const toggleClickable = () => {
+      const newValue = props.show && props.forbidClick;
+      if (clickable !== newValue) {
+        clickable = newValue;
+        (0, import_lock_click.lockClick)(clickable);
       }
-
-      if (type === 'loading') {
-        return h(_loading.default, {
-          "class": bem('loading'),
-          "attrs": {
-            "type": loadingType
-          }
-        });
+    };
+    const updateShow = (show) => emit("update:show", show);
+    const onClick = () => {
+      if (props.closeOnClick) {
+        updateShow(false);
       }
-    },
-    genMessage: function genMessage() {
-      var h = this.$createElement;
-      var type = this.type,
-          message = this.message;
-
-      if (!(0, _utils.isDef)(message) || message === '') {
-        return;
+    };
+    const clearTimer = () => clearTimeout(timer);
+    const renderIcon = () => {
+      const {
+        icon,
+        type,
+        iconSize,
+        iconPrefix,
+        loadingType
+      } = props;
+      const hasIcon = icon || type === "success" || type === "warning";
+      if (hasIcon) {
+        return (0, import_vue.createVNode)(import_icon.Icon, {
+          "name": icon || type,
+          "size": iconSize,
+          "class": bem("icon"),
+          "classPrefix": iconPrefix
+        }, null);
       }
-
-      if (type === 'html') {
-        return h("div", {
-          "class": bem('text'),
-          "domProps": {
-            "innerHTML": message
-          }
-        });
+      if (type === "loading") {
+        return (0, import_vue.createVNode)(import_loading.Loading, {
+          "class": bem("loading"),
+          "size": iconSize,
+          "type": loadingType
+        }, null);
       }
-
-      return h("div", {
-        "class": bem('text')
-      }, [message]);
-    }
-  },
-  render: function render() {
-    var _ref;
-
-    var h = arguments[0];
-    return h("transition", {
-      "attrs": {
-        "name": this.transition
-      },
-      "on": {
-        "afterEnter": this.onAfterEnter,
-        "afterLeave": this.onAfterLeave
+    };
+    const renderMessage = () => {
+      const {
+        type,
+        message
+      } = props;
+      if ((0, import_utils.isDef)(message) && message !== "") {
+        return type === "html" ? (0, import_vue.createVNode)("div", {
+          "key": 0,
+          "class": bem("text"),
+          "innerHTML": String(message)
+        }, null) : (0, import_vue.createVNode)("div", {
+          "class": bem("text")
+        }, [message]);
       }
-    }, [h("div", {
-      "directives": [{
-        name: "show",
-        value: this.value
-      }],
-      "class": [bem([this.position, (_ref = {}, _ref[this.type] = !this.icon, _ref)]), this.className],
-      "on": {
-        "click": this.onClick
+    };
+    (0, import_vue2.watch)(() => [props.show, props.forbidClick], toggleClickable);
+    (0, import_vue2.watch)(() => [props.show, props.type, props.message, props.duration], () => {
+      clearTimer();
+      if (props.show && props.duration > 0) {
+        timer = setTimeout(() => {
+          updateShow(false);
+        }, props.duration);
       }
-    }, [this.genIcon(), this.genMessage()])]);
+    });
+    (0, import_vue2.onMounted)(toggleClickable);
+    (0, import_vue2.onUnmounted)(toggleClickable);
+    return () => (0, import_vue.createVNode)(import_popup.Popup, (0, import_vue.mergeProps)({
+      "class": [bem([props.position, {
+        [props.type]: !props.icon
+      }]), props.className],
+      "lockScroll": false,
+      "onClick": onClick,
+      "onClosed": clearTimer,
+      "onUpdate:show": updateShow
+    }, (0, import_utils.pick)(props, popupInheritProps)), {
+      default: () => [renderIcon(), renderMessage()]
+    });
   }
 });
-
-exports.default = _default;

package/lib/toast/function-call.d.ts

@@ -0,0 +1,10 @@
+import type { ToastType, ToastOptions, ToastWrapperInstance } from './types';
+export declare function showToast(options?: string | ToastOptions): ToastWrapperInstance;
+export declare const showLoadingToast: (options: string | ToastOptions) => ToastWrapperInstance;
+export declare const showSuccessToast: (options: string | ToastOptions) => ToastWrapperInstance;
+export declare const showFailToast: (options: string | ToastOptions) => ToastWrapperInstance;
+export declare const closeToast: (all?: boolean) => void;
+export declare function setToastDefaultOptions(options: ToastOptions): void;
+export declare function setToastDefaultOptions(type: ToastType, options: ToastOptions): void;
+export declare const resetToastDefaultOptions: (type?: ToastType) => void;
+export declare const allowMultipleToast: (value?: boolean) => void;