ninemoon-ui 0.0.1

package/dist/js/dialog/dialog.js

@@ -0,0 +1,140 @@
+import { defineComponent, computed, watch, openBlock, createBlock, Teleport, createVNode, Transition, withCtx, withDirectives, createElementVNode, withModifiers, normalizeClass, normalizeStyle, createElementBlock, toDisplayString, createCommentVNode, renderSlot, vShow } from "vue";
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = {
+  key: 0,
+  class: "tdd-flex tdd-w-full tdd-justify-between tdd-p-2"
+};
+const _hoisted_3 = /* @__PURE__ */ createElementVNode("svg", {
+  class: "tdd-h-5 tdd-w-5 tdd-fill-gray-600",
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  viewBox: "0 0 24 24",
+  fill: "none"
+}, [
+  /* @__PURE__ */ createElementVNode("g", null, [
+    /* @__PURE__ */ createElementVNode("path", {
+      "fill-rule": "evenodd",
+      "clip-rule": "evenodd",
+      d: "M16.7782 7.22943C16.4824 6.93364 16.0046 6.93364 15.7088 7.22943L12 10.9306L8.29124 7.22184C7.99545 6.92605 7.51763 6.92605 7.22184 7.22184C6.92605 7.51763 6.92605 7.99545 7.22184 8.29124L10.9306 12L7.22184 15.7088C6.92605 16.0046 6.92605 16.4824 7.22184 16.7782C7.51763 17.0739 7.99545 17.0739 8.29124 16.7782L12 13.0694L15.7088 16.7782C16.0046 17.0739 16.4824 17.0739 16.7782 16.7782C17.0739 16.4824 17.0739 16.0046 16.7782 15.7088L13.0694 12L16.7782 8.29124C17.0664 8.00303 17.0664 7.51763 16.7782 7.22943Z",
+      fill: "inherit"
+    })
+  ])
+], -1);
+const _hoisted_4 = [
+  _hoisted_3
+];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "dialog",
+  props: {
+    visible: { type: Boolean, default: false },
+    title: {},
+    beforeHidden: {},
+    bodyClickAble: { type: Boolean, default: true },
+    headShow: { type: Boolean, default: true },
+    width: {},
+    isDiy: { type: Boolean, default: false },
+    lockScroll: { type: Boolean, default: true }
+  },
+  emits: ["update:visible"],
+  setup(__props, { emit: UpdateVisible }) {
+    const props = __props;
+    const showdefaultHand = computed(() => {
+      return props.headShow && !props.isDiy;
+    });
+    const hasselfwidth = computed(() => {
+      if (props.width) {
+        return true;
+      } else {
+        return false;
+      }
+    });
+    const selfwidth = computed(() => {
+      if (props.width) {
+        if (typeof props.width === "number") {
+          return `${props.width}px`;
+        } else if (typeof props.width === "string") {
+          if (props.width.includes("px") || props.width.includes("%")) {
+            return props.width;
+          } else {
+            return `${props.width}px`;
+          }
+        } else {
+          return "unset";
+        }
+      } else {
+        return "unset";
+      }
+    });
+    const dialogHidden = (cancelflag) => {
+      if (cancelflag !== false) {
+        UpdateVisible("update:visible", false);
+      }
+    };
+    const closeIcon = (e) => {
+      if (props.beforeHidden) {
+        props.beforeHidden(dialogHidden);
+      } else {
+        dialogHidden();
+      }
+      return e;
+    };
+    const bodyClick = (e) => {
+      if (props.bodyClickAble) {
+        closeIcon(e);
+      }
+      return e;
+    };
+    watch(
+      () => props.visible,
+      (val) => {
+        if (props.lockScroll) {
+          if (val === true) {
+            document.getElementsByTagName("body")[0].className = "overflow-hidden";
+          } else {
+            document.getElementsByTagName("body")[0].className = "block";
+          }
+        }
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Teleport, {
+        to: "body",
+        disabled: !_ctx.visible
+      }, [
+        createVNode(Transition, { name: "opecity" }, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", {
+              class: "tdd-fixed tdd-top-0 tdd-right-0 tdd-left-0 tdd-bottom-0 tdd-bg-black tdd-bg-opacity-30 tdd-text-sm tdd-z-1000 tdd-flex tdd-items-center tdd-justify-center",
+              onClick: withModifiers(bodyClick, ["self"])
+            }, [
+              createElementVNode("div", {
+                class: normalizeClass(["tdd-z-50 tdd-divide-y tdd-divide-gray-300 tdd-rounded tdd-drop-shadow", { "tdd-w-96": !hasselfwidth.value, "tdd-bg-white": !_ctx.isDiy }]),
+                style: normalizeStyle({ width: selfwidth.value })
+              }, [
+                showdefaultHand.value ? (openBlock(), createElementBlock("div", _hoisted_2, [
+                  createElementVNode("span", null, toDisplayString(_ctx.title), 1),
+                  createElementVNode("button", {
+                    type: "button",
+                    onClick: closeIcon
+                  }, _hoisted_4)
+                ])) : createCommentVNode("", true),
+                createElementVNode("div", {
+                  class: normalizeClass({ "tdd-p-2": !_ctx.isDiy })
+                }, [
+                  renderSlot(_ctx.$slots, "default")
+                ], 2)
+              ], 6)
+            ], 8, _hoisted_1), [
+              [vShow, _ctx.visible]
+            ])
+          ]),
+          _: 3
+        })
+      ], 8, ["disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/js/form/form.js

@@ -0,0 +1,85 @@
+import { defineComponent, readonly, ref, provide, openBlock, createElementBlock, renderSlot } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "form",
+  props: {
+    rule: {},
+    model: {},
+    inline: { type: Boolean, default: true }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const staticModel = readonly(Object.assign({}, props.model));
+    const checkList = ref([]);
+    const pushCheck = (name, fc) => {
+      if (name == null)
+        return;
+      checkList.value.push({
+        name,
+        fc
+      });
+    };
+    const clearList = ref([]);
+    const pushClear = (i) => {
+      clearList.value.push(i);
+    };
+    const validate = async (callBack) => {
+      let passflag = true;
+      for (const rule of checkList.value) {
+        await rule.fc((msg) => {
+          if (msg !== null && msg !== void 0) {
+            passflag = false;
+            console.warn(msg);
+          }
+        });
+      }
+      if (passflag === true) {
+        callBack(passflag);
+      }
+    };
+    const validateField = async (propname, callBack) => {
+      if (!propname) {
+        throw new Error("prop参数为空");
+      } else {
+        const ruleArr = checkList.value.filter((check) => check.name === propname);
+        if (ruleArr.length === 0) {
+          throw new Error("没有匹配的检查函数");
+        } else {
+          for (const rule of ruleArr) {
+            await rule.fc((msg) => {
+              console.warn(msg);
+              callBack(msg);
+            });
+          }
+        }
+      }
+    };
+    const resetField = () => {
+      for (const clearFun of clearList.value) {
+        clearFun();
+      }
+      for (const key in props.model) {
+        if (Object.prototype.hasOwnProperty.call(props.model, key)) {
+          props.model[key] = staticModel[key];
+        }
+      }
+    };
+    __expose({
+      validate,
+      validateField,
+      resetField
+    });
+    provide("rule", props.rule);
+    provide("model", props.model);
+    provide("sendCheck", pushCheck);
+    provide("sendClear", pushClear);
+    provide("inlineStatus", props.inline);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("form", null, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/js/form/formlabel.js

@@ -0,0 +1,167 @@
+import { defineComponent, inject, computed, ref, provide, openBlock, createElementBlock, createElementVNode, normalizeClass, normalizeStyle, toDisplayString, renderSlot, createCommentVNode } from "vue";
+const _hoisted_1 = { class: "tdd-mb-5" };
+const _hoisted_2 = { class: "tdd-relative tdd-flex-1 tdd-items-center" };
+const _hoisted_3 = {
+  key: 0,
+  class: "tdd-absolute tdd--bottom-5 tdd-left-0 tdd-text-xs tdd-text-red-600"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "formlabel",
+  props: {
+    label: {},
+    prop: {},
+    inline: { type: Boolean, default: void 0 },
+    width: { default: 70 }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const Rules = inject("rule");
+    const Model = inject("model");
+    const sendCheck = inject("sendCheck", () => null);
+    const sendClear = inject("sendClear", () => null);
+    const totalInlineStatues = inject("inlineStatus");
+    const isInline = computed(() => {
+      if (props.inline != null) {
+        return props.inline;
+      } else {
+        return totalInlineStatues;
+      }
+    });
+    const tip = ref(null);
+    const showTip = computed(() => tip.value != null && tip.value != "");
+    const thisRules = Rules && props.prop && Rules[props.prop];
+    const resetField = () => {
+      tip.value = null;
+    };
+    const FunctionToPromise = (callBack, receiveData) => {
+      return new Promise((resolve) => {
+        callBack(receiveData, (result) => {
+          resolve(result);
+        });
+      });
+    };
+    const mixHandle = async (receiveData, eventname) => {
+      if (thisRules instanceof Array) {
+        for (let i = 0; i < thisRules.length; i++) {
+          const { type, trigger, min, max, message, validator } = thisRules[i];
+          if (trigger === "blur" && eventname === "blurevent" || trigger === "input" && eventname === "inputevent" || trigger === "change" && eventname === "changeevent") {
+            if (min || max) {
+              if (isNaN(Number(receiveData))) {
+                tip.value = "请输入数字";
+                break;
+              } else {
+                if (min && Number(receiveData) < min || max && Number(receiveData) > max) {
+                  tip.value = message;
+                  break;
+                }
+              }
+            } else if (validator) {
+              const result = await FunctionToPromise(validator, receiveData);
+              tip.value = result;
+              if (result != null) {
+                break;
+              }
+            } else if (type == "array") {
+              if (!(receiveData instanceof Array)) {
+                tip.value = message;
+                break;
+              } else if (receiveData.length === 0) {
+                tip.value = message;
+                break;
+              } else {
+                tip.value = null;
+              }
+            } else if (receiveData == null || receiveData == "") {
+              tip.value = message;
+              break;
+            } else {
+              tip.value = null;
+            }
+          }
+        }
+      }
+    };
+    const inputHandle = (data) => mixHandle(data, "inputevent");
+    const blurHandle = (data) => mixHandle(data, "blurevent");
+    const changeHandle = (data) => mixHandle(data, "changeevent");
+    const validateLabel = async (callBack) => {
+      let flag = 0;
+      const data = Model[props.prop];
+      if (thisRules instanceof Array) {
+        for (let i = 0; i < thisRules.length; i++) {
+          const { type, min, max, message, validator } = thisRules[i];
+          if (min || max) {
+            if (isNaN(Number(data))) {
+              callBack("请输入数字");
+              flag += 1;
+              break;
+            } else {
+              if (max && Number(data) > max || min && Number(data) < min) {
+                tip.value = message;
+                callBack(message);
+                flag += 1;
+                break;
+              }
+            }
+          } else if (validator) {
+            const result = await FunctionToPromise(validator, data);
+            tip.value = result;
+            if (result != null) {
+              callBack(result);
+              flag += 1;
+              break;
+            }
+          } else if (type == "array") {
+            if (!(data instanceof Array)) {
+              tip.value = message;
+              callBack(message);
+              flag += 1;
+              break;
+            } else if (data.length === 0) {
+              tip.value = message;
+              callBack(message);
+              flag += 1;
+              break;
+            }
+          } else if (data == null || data == "") {
+            tip.value = message;
+            callBack(message);
+            flag += 1;
+            break;
+          }
+        }
+      }
+      if (flag === 0) {
+        tip.value = null;
+        callBack();
+      }
+    };
+    sendCheck(props.prop, validateLabel);
+    sendClear(resetField);
+    provide("inputHandle", inputHandle);
+    provide("blurHandle", blurHandle);
+    provide("changHandle", changeHandle);
+    __expose({
+      validateLabel
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          class: normalizeClass(["tdd-w-full tdd-flex", { "tdd-flex-col": !isInline.value, "tdd-items-center": isInline.value }])
+        }, [
+          createElementVNode("div", {
+            class: "tdd-text-sm",
+            style: normalizeStyle({ width: `${_ctx.width}px` })
+          }, toDisplayString(_ctx.label), 5),
+          createElementVNode("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "default"),
+            showTip.value ? (openBlock(), createElementBlock("div", _hoisted_3, toDisplayString(tip.value), 1)) : createCommentVNode("", true)
+          ])
+        ], 2)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/js/getcalendar/getcalendar.js

@@ -0,0 +1,48 @@
+const getMonthDays = (year, month, flag) => {
+  let stratDate = new Date(year, month - 1, 1).getTime(), endData = new Date(year, month, 1).getTime();
+  let days = (endData - stratDate) / (1e3 * 60 * 60 * 24);
+  let list = [];
+  for (let i = 1; i <= days; i++) {
+    const d = i;
+    const week = (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 0 ? "日" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 1 ? "一" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 2 ? "二" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 3 ? "三" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 4 ? "四" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 5 ? "五" : (/* @__PURE__ */ new Date(month + "/" + i + "/" + year)).getDay() == 6 ? "六" : "";
+    let obj = {
+      week,
+      d,
+      m: month,
+      y: year,
+      isChoosed1Day: false,
+      isChoosed2Day: false
+    };
+    if (flag === 1) {
+      Object.assign(obj, {
+        pred: true
+      });
+    } else if (flag === 2) {
+      Object.assign(obj, {
+        nextd: true
+      });
+    } else {
+      Object.assign(obj, {
+        newd: true
+      });
+    }
+    list.push(obj);
+  }
+  return list;
+};
+const addZero = (data) => {
+  let t = Number(data);
+  if (isNaN(t)) {
+    throw new Error("日期格式不正确");
+  } else {
+    if (t < 10) {
+      return `0${t}`;
+    } else {
+      return `${t}`;
+    }
+  }
+};
+export {
+  addZero as a,
+  getMonthDays as g
+};