@nutui/nutui 3.1.6 → 3.1.7

package/dist/packages/_es/DatePicker.js

@@ -0,0 +1,282 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/*!
+* @nutui/nutui v3.1.7 Thu Sep 30 2021 20:17:02 GMT+0800 (中国标准时间)
+* (c) 2021 @jdf2e.
+* Released under the MIT License.
+*/
+import { reactive, computed, onMounted, watch, toRefs, resolveComponent, openBlock, createBlock } from "vue";
+import picker from "./Picker.js";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "./index.js";
+import "./Popup.js";
+import "./OverLay.js";
+import "./Icon.js";
+import "./pxCheck.js";
+const { componentName, create } = createComponent("datepicker");
+const currentYear = new Date().getFullYear();
+function isDate(val) {
+  return Object.prototype.toString.call(val) === "[object Date]" && !isNaN(val.getTime());
+}
+const zhCNType = {
+  day: "\u65E5",
+  year: "\u5E74",
+  month: "\u6708",
+  hour: "\u65F6",
+  minute: "\u5206",
+  seconds: "\u79D2"
+};
+const _sfc_main = create({
+  components: {
+    [picker.name]: picker
+  },
+  props: {
+    modelValue: null,
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "date"
+    },
+    isShowChinese: {
+      type: Boolean,
+      default: true
+    },
+    minuteStep: {
+      type: Number,
+      default: 1
+    },
+    minDate: {
+      type: Date,
+      default: () => new Date(currentYear - 10, 0, 1),
+      validator: isDate
+    },
+    maxDate: {
+      type: Date,
+      default: () => new Date(currentYear + 10, 11, 31),
+      validator: isDate
+    }
+  },
+  emits: ["click", "update:visible", "confirm"],
+  setup(props, { emit }) {
+    const state = reactive({
+      show: false,
+      currentDate: new Date(),
+      title: props.title
+    });
+    const formatValue = (value) => {
+      if (!isDate(value)) {
+        value = props.minDate;
+      }
+      let timestmp = Math.max(value.getTime(), props.minDate.getTime());
+      timestmp = Math.min(timestmp, props.maxDate.getTime());
+      return new Date(timestmp);
+    };
+    function getMonthEndDay(year, month) {
+      return 32 - new Date(year, month - 1, 32).getDate();
+    }
+    const getBoundary = (type, value) => {
+      const boundary = props[`${type}Date`];
+      const year = boundary.getFullYear();
+      let month = 1;
+      let date = 1;
+      let hour = 0;
+      let minute = 0;
+      if (type === "max") {
+        month = 12;
+        date = getMonthEndDay(value.getFullYear(), value.getMonth() + 1);
+        hour = 23;
+        minute = 59;
+      }
+      const seconds = minute;
+      if (value.getFullYear() === year) {
+        month = boundary.getMonth() + 1;
+        if (value.getMonth() + 1 === month) {
+          date = boundary.getDate();
+          if (value.getDate() === date) {
+            hour = boundary.getHours();
+            if (value.getHours() === hour) {
+              minute = boundary.getMinutes();
+            }
+          }
+        }
+      }
+      return {
+        [`${type}Year`]: year,
+        [`${type}Month`]: month,
+        [`${type}Date`]: date,
+        [`${type}Hour`]: hour,
+        [`${type}Minute`]: minute,
+        [`${type}Seconds`]: seconds
+      };
+    };
+    const ranges = computed(() => {
+      const { maxYear, maxDate, maxMonth, maxHour, maxMinute, maxSeconds } = getBoundary("max", state.currentDate);
+      const { minYear, minDate, minMonth, minHour, minMinute, minSeconds } = getBoundary("min", state.currentDate);
+      let result = [
+        {
+          type: "year",
+          range: [minYear, maxYear]
+        },
+        {
+          type: "month",
+          range: [minMonth, maxMonth]
+        },
+        {
+          type: "day",
+          range: [minDate, maxDate]
+        },
+        {
+          type: "hour",
+          range: [minHour, maxHour]
+        },
+        {
+          type: "minute",
+          range: [minMinute, maxMinute]
+        },
+        {
+          type: "seconds",
+          range: [minSeconds, maxSeconds]
+        }
+      ];
+      switch (props.type) {
+        case "date":
+          result = result.slice(0, 3);
+          break;
+        case "datetime":
+          result = result.slice(0, 5);
+          break;
+        case "time":
+          result = result.slice(3, 6);
+          break;
+        case "month-day":
+          result = result.slice(1, 3);
+          break;
+        case "datehour":
+          result = result.slice(0, 4);
+          break;
+      }
+      return result;
+    });
+    const changeHandler = (val) => {
+      if (["date", "datetime"].includes(props.type)) {
+        let formatDate = [];
+        if (props.isShowChinese) {
+          formatDate = val.map((res) => {
+            return Number(res.slice(0, res.length - 1));
+          });
+        } else {
+          formatDate = val;
+        }
+        if (props.type === "date") {
+          state.currentDate = formatValue(new Date(formatDate[0], formatDate[1] - 1, Math.min(formatDate[2], getMonthEndDay(formatDate[0], formatDate[1]))));
+        } else if (props.type === "datetime") {
+          state.currentDate = formatValue(new Date(formatDate[0], formatDate[1] - 1, Math.min(formatDate[2], getMonthEndDay(formatDate[0], formatDate[1])), formatDate[3], formatDate[4]));
+        }
+      }
+    };
+    const generateValue = (min, max, val, type) => {
+      if (!(max > min))
+        return;
+      const arr = [];
+      let index2 = 0;
+      while (min <= max) {
+        if (props.isShowChinese) {
+          arr.push(min + zhCNType[type]);
+        } else {
+          arr.push(min);
+        }
+        if (type === "minute") {
+          min += props.minuteStep;
+        } else {
+          min++;
+        }
+        if (min <= val) {
+          index2++;
+        }
+      }
+      return { values: arr, defaultIndex: index2 };
+    };
+    const getDateIndex = (type) => {
+      if (type === "year") {
+        return state.currentDate.getFullYear();
+      } else if (type === "month") {
+        return state.currentDate.getMonth() + 1;
+      } else if (type === "day") {
+        return state.currentDate.getDate();
+      } else if (type === "hour") {
+        return state.currentDate.getHours();
+      } else if (type === "minute") {
+        return state.currentDate.getMinutes();
+      } else if (type === "seconds") {
+        return state.currentDate.getSeconds();
+      }
+      return 0;
+    };
+    const columns = computed(() => {
+      const val = ranges.value.map((res) => {
+        return generateValue(res.range[0], res.range[1], getDateIndex(res.type), res.type);
+      });
+      return val;
+    });
+    const closeHandler = () => {
+      emit("update:visible", false);
+    };
+    const confirm = (val) => {
+      emit("update:visible", false);
+      emit("confirm", val);
+    };
+    onMounted(() => {
+      state.currentDate = formatValue(props.modelValue);
+    });
+    watch(() => props.title, (val) => {
+      state.title = val;
+    });
+    watch(() => props.visible, (val) => {
+      state.show = val;
+    });
+    return __spreadProps(__spreadValues({}, toRefs(state)), {
+      changeHandler,
+      closeHandler,
+      confirm,
+      columns
+    });
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_picker = resolveComponent("nut-picker");
+  return openBlock(), createBlock(_component_nut_picker, {
+    visible: _ctx.show,
+    onClose: _ctx.closeHandler,
+    "list-data": _ctx.columns,
+    onChange: _ctx.changeHandler,
+    title: _ctx.title,
+    onConfirm: _ctx.confirm
+  }, null, 8, ["visible", "onClose", "list-data", "onChange", "title", "onConfirm"]);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Dialog.js

@@ -0,0 +1,313 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+/*!
+* @nutui/nutui v3.1.7 Thu Sep 30 2021 20:17:02 GMT+0800 (中国标准时间)
+* (c) 2021 @jdf2e.
+* Released under the MIT License.
+*/
+import { ref, onMounted, watch, computed, resolveComponent, openBlock, createBlock, withCtx, createElementVNode, normalizeClass, createElementBlock, renderSlot, Fragment, createTextVNode, toDisplayString, createCommentVNode, normalizeStyle, createVNode, render, h } from "vue";
+import { c as createComponent } from "./component.js";
+import Popup, { popupProps } from "./Popup.js";
+import Button from "./Button.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "./OverLay.js";
+import "./Icon.js";
+import "./pxCheck.js";
+const { componentName, create } = createComponent("dialog");
+const _sfc_main = create({
+  inheritAttrs: false,
+  components: {
+    [Popup.name]: Popup,
+    [Button.name]: Button
+  },
+  props: __spreadProps(__spreadValues({}, popupProps), {
+    closeOnClickOverlay: {
+      type: Boolean,
+      default: false
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    content: {
+      type: String,
+      default: ""
+    },
+    noFooter: {
+      type: Boolean,
+      default: false
+    },
+    noOkBtn: {
+      type: Boolean,
+      default: false
+    },
+    noCancelBtn: {
+      type: Boolean,
+      default: false
+    },
+    cancelText: {
+      type: String,
+      default: "\u53D6\u6D88"
+    },
+    okText: {
+      type: String,
+      default: "\u786E\u5B9A"
+    },
+    okBtnDisabled: {
+      type: Boolean,
+      default: false
+    },
+    cancelAutoClose: {
+      type: Boolean,
+      default: true
+    },
+    textAlign: {
+      type: String,
+      default: "center"
+    },
+    onOk: {
+      type: Function,
+      default: null
+    },
+    onCancel: {
+      type: Function,
+      default: null
+    },
+    onClose: {
+      type: Function,
+      default: null
+    },
+    onClosed: {
+      type: Function,
+      default: null
+    },
+    closeOnPopstate: {
+      type: Boolean,
+      default: false
+    }
+  }),
+  emits: [
+    "update",
+    "update:visible",
+    "ok",
+    "cancel",
+    "open",
+    "opened",
+    "close",
+    "closed"
+  ],
+  setup(props, { emit }) {
+    const showPopup = ref(props.visible);
+    onMounted(() => {
+      if (props.closeOnPopstate) {
+        window.addEventListener("popstate", function() {
+          closed();
+        });
+      }
+    });
+    watch(() => props.visible, (value) => {
+      showPopup.value = value;
+    });
+    const classes = computed(() => {
+      return {
+        [componentName]: true
+      };
+    });
+    const update = (val) => {
+      emit("update", val);
+      emit("update:visible", val);
+    };
+    const closed = () => {
+      update(false);
+      emit("closed");
+    };
+    const onCancel = () => {
+      emit("cancel");
+      if (props.cancelAutoClose) {
+        closed();
+      }
+    };
+    const onOk = () => {
+      closed();
+      emit("ok");
+    };
+    return {
+      closed,
+      classes,
+      onCancel,
+      onOk,
+      showPopup
+    };
+  }
+});
+const _hoisted_1 = {
+  key: 0,
+  class: "nut-dialog__header"
+};
+const _hoisted_2 = ["innerHTML"];
+const _hoisted_3 = {
+  key: 1,
+  class: "nut-dialog__footer"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_button = resolveComponent("nut-button");
+  const _component_nut_popup = resolveComponent("nut-popup");
+  return openBlock(), createBlock(_component_nut_popup, {
+    teleport: _ctx.teleport,
+    visible: _ctx.showPopup,
+    "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => _ctx.showPopup = $event),
+    "close-on-click-overlay": _ctx.closeOnClickOverlay,
+    "lock-scroll": _ctx.lockScroll,
+    round: "",
+    onClickOverlay: _ctx.closed,
+    onClickCloseIcon: _ctx.closed
+  }, {
+    default: withCtx(() => [
+      createElementVNode("view", {
+        class: normalizeClass(_ctx.classes)
+      }, [
+        _ctx.title ? (openBlock(), createElementBlock("view", _hoisted_1, [
+          _ctx.$slots.header ? renderSlot(_ctx.$slots, "header", { key: 0 }) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+            createTextVNode(toDisplayString(_ctx.title), 1)
+          ], 64))
+        ])) : createCommentVNode("", true),
+        createElementVNode("view", {
+          class: "nut-dialog__content",
+          style: normalizeStyle({ textAlign: _ctx.textAlign })
+        }, [
+          _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock("view", {
+            key: 1,
+            innerHTML: _ctx.content
+          }, null, 8, _hoisted_2))
+        ], 4),
+        !_ctx.noFooter ? (openBlock(), createElementBlock("view", _hoisted_3, [
+          _ctx.$slots.footer ? renderSlot(_ctx.$slots, "footer", { key: 0 }) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+            !_ctx.noCancelBtn ? (openBlock(), createBlock(_component_nut_button, {
+              key: 0,
+              size: "small",
+              plain: "",
+              type: "primary",
+              class: "nut-dialog__footer-cancel",
+              onClick: _ctx.onCancel
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.cancelText), 1)
+              ]),
+              _: 1
+            }, 8, ["onClick"])) : createCommentVNode("", true),
+            !_ctx.noOkBtn ? (openBlock(), createBlock(_component_nut_button, {
+              key: 1,
+              size: "small",
+              type: "primary",
+              class: normalizeClass(["nut-dialog__footer-ok", { disabled: _ctx.okBtnDisabled }]),
+              disabled: _ctx.okBtnDisabled,
+              onClick: _ctx.onOk
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.okText), 1)
+              ]),
+              _: 1
+            }, 8, ["class", "disabled", "onClick"])) : createCommentVNode("", true)
+          ], 64))
+        ])) : createCommentVNode("", true)
+      ], 2)
+    ]),
+    _: 3
+  }, 8, ["teleport", "visible", "close-on-click-overlay", "lock-scroll", "onClickOverlay", "onClickCloseIcon"]);
+}
+var Dialog = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+class DialogOptions {
+  constructor() {
+    __publicField(this, "title", "");
+    __publicField(this, "content", "");
+    __publicField(this, "cancelText", "\u53D6\u6D88");
+    __publicField(this, "okText", "\u786E\u5B9A");
+    __publicField(this, "textAlign", "center");
+    __publicField(this, "teleport", "body");
+    __publicField(this, "onUpdate", (value) => {
+    });
+    __publicField(this, "onOk", () => {
+    });
+    __publicField(this, "onCancel", () => {
+    });
+    __publicField(this, "onClose", () => {
+    });
+    __publicField(this, "onClosed", () => {
+    });
+    __publicField(this, "visible", true);
+    __publicField(this, "noFooter", false);
+    __publicField(this, "noOkBtn", false);
+    __publicField(this, "noCancelBtn", false);
+    __publicField(this, "okBtnDisabled", false);
+    __publicField(this, "closeOnPopstate", false);
+    __publicField(this, "lockScroll", false);
+  }
+}
+class DialogFunction {
+  constructor(_options) {
+    __publicField(this, "options", new DialogOptions());
+    __publicField(this, "close", () => {
+    });
+    __publicField(this, "setDefaultOptions", (options) => {
+    });
+    __publicField(this, "resetDefaultOptions", () => {
+    });
+    let options = Object.assign(this.options, _options);
+    let elWarp = document.body;
+    let teleport = options.teleport;
+    if (teleport != "body") {
+      if (typeof teleport == "string") {
+        elWarp = document.querySelector(teleport);
+      } else {
+        elWarp = options.teleport;
+      }
+    }
+    const root = document.createElement("view");
+    root.id = "dialog-" + new Date().getTime();
+    const Wrapper = {
+      setup() {
+        options.onUpdate = (val) => {
+          if (val == false) {
+            elWarp.removeChild(root);
+          }
+        };
+        options.teleport = `#${root.id}`;
+        return () => {
+          return h(Dialog, options);
+        };
+      }
+    };
+    const instance = createVNode(Wrapper);
+    elWarp.appendChild(root);
+    render(instance, root);
+  }
+}
+const _Dialog = function(options) {
+  return new DialogFunction(options);
+};
+_Dialog.install = (app) => {
+  app.use(Dialog);
+  app.config.globalProperties.$dialog = _Dialog;
+};
+export { Dialog, DialogOptions, _Dialog as default };

package/dist/packages/_es/Divider.js

@@ -0,0 +1,49 @@
+/*!
+* @nutui/nutui v3.1.7 Thu Sep 30 2021 20:17:02 GMT+0800 (中国标准时间)
+* (c) 2021 @jdf2e.
+* Released under the MIT License.
+*/
+import { computed, openBlock, createElementBlock, normalizeClass, renderSlot } from "vue";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+const { componentName, create } = createComponent("divider");
+const _sfc_main = create({
+  props: {
+    contentPosition: {
+      type: String,
+      default: "center"
+    },
+    dashed: {
+      type: Boolean,
+      default: false
+    },
+    hairline: {
+      type: Boolean,
+      default: true
+    }
+  },
+  components: {},
+  setup(props, context) {
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true,
+        [`${prefixCls}-center`]: context.slots.default,
+        [`${prefixCls}-left`]: props.contentPosition === "left",
+        [`${prefixCls}-right`]: props.contentPosition === "right",
+        [`${prefixCls}-dashed`]: props.dashed,
+        [`${prefixCls}-hairline`]: props.hairline
+      };
+    });
+    return { classes };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(_ctx.classes)
+  }, [
+    renderSlot(_ctx.$slots, "default")
+  ], 2);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };