@nutui/nutui 4.0.11 → 4.0.12

package/dist/packages/_es/Watermark.js

@@ -1,20 +1,28 @@
-var B = Object.defineProperty, H = Object.defineProperties;
-var R = Object.getOwnPropertyDescriptors;
-var k = Object.getOwnPropertySymbols;
-var _ = Object.prototype.hasOwnProperty, A = Object.prototype.propertyIsEnumerable;
-var I = (e, a, t) => a in e ? B(e, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[a] = t, v = (e, a) => {
-  for (var t in a || (a = {}))
-    _.call(a, t) && I(e, t, a[t]);
-  if (k)
-    for (var t of k(a))
-      A.call(a, t) && I(e, t, a[t]);
-  return e;
-}, C = (e, a) => H(e, R(a));
-import { reactive as E, watch as F, computed as X, toRefs as D, openBlock as L, createElementBlock as M, normalizeClass as Y, normalizeStyle as O } from "vue";
-import { c as T } from "./component-234624bc.js";
-import { _ as j } from "./_plugin-vue_export-helper-dad06003.js";
+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));
+import { reactive, watch, computed, toRefs, openBlock, createElementBlock, normalizeClass, normalizeStyle } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
 import "../locale/lang";
-const { componentName: q, create: G } = T("watermark"), J = G({
+const { componentName, create } = createComponent("watermark");
+const _sfc_main = create({
   props: {
     name: {
       type: String,
@@ -86,91 +94,116 @@ const { componentName: q, create: G } = T("watermark"), J = G({
     }
   },
   emits: ["click"],
-  setup(e, { emit: a }) {
-    const t = E({
+  setup(props, { emit }) {
+    const state = reactive({
       base64Url: ""
-    }), {
-      zIndex: h,
-      gapX: l,
-      gapY: s,
-      width: m,
-      height: c,
-      rotate: u,
-      image: f,
-      imageWidth: d,
-      imageHeight: p,
-      content: g,
-      fontStyle: b,
-      fontWeight: S,
-      fontColor: x,
-      fontSize: $,
-      fontFamily: w
-    } = e, N = () => {
-      const o = document.createElement("canvas"), n = window.devicePixelRatio, r = o.getContext("2d"), U = `${(l + m) * n}px`, W = `${(s + c) * n}px`, z = m * n, y = c * n;
-      if (o.setAttribute("width", U), o.setAttribute("height", W), r) {
-        if (f) {
-          r.translate(z / 2, y / 2), r.rotate(Math.PI / 180 * Number(u));
-          const i = new Image();
-          i.crossOrigin = "anonymous", i.referrerPolicy = "no-referrer", i.src = f, i.onload = () => {
-            r.drawImage(
-              i,
-              -d * n / 2,
-              -p * n / 2,
-              d * n,
-              p * n
-            ), r.restore(), t.base64Url = o.toDataURL();
+    });
+    const {
+      zIndex,
+      gapX,
+      gapY,
+      width,
+      height,
+      rotate,
+      image,
+      imageWidth,
+      imageHeight,
+      content,
+      fontStyle,
+      fontWeight,
+      fontColor,
+      fontSize,
+      fontFamily
+    } = props;
+    const init = () => {
+      const canvas = document.createElement("canvas");
+      const ratio = window.devicePixelRatio;
+      const ctx = canvas.getContext("2d");
+      const canvasWidth = `${(gapX + width) * ratio}px`;
+      const canvasHeight = `${(gapY + height) * ratio}px`;
+      const markWidth = width * ratio;
+      const markHeight = height * ratio;
+      canvas.setAttribute("width", canvasWidth);
+      canvas.setAttribute("height", canvasHeight);
+      if (ctx) {
+        if (image) {
+          ctx.translate(markWidth / 2, markHeight / 2);
+          ctx.rotate(Math.PI / 180 * Number(rotate));
+          const img = new Image();
+          img.crossOrigin = "anonymous";
+          img.referrerPolicy = "no-referrer";
+          img.src = image;
+          img.onload = () => {
+            ctx.drawImage(
+              img,
+              -imageWidth * ratio / 2,
+              -imageHeight * ratio / 2,
+              imageWidth * ratio,
+              imageHeight * ratio
+            );
+            ctx.restore();
+            state.base64Url = canvas.toDataURL();
           };
-        } else if (g) {
-          r.textBaseline = "middle", r.textAlign = "center", r.translate(z / 2, y / 2), r.rotate(Math.PI / 180 * Number(u));
-          const i = Number($) * n;
-          r.font = `${b} normal ${S} ${i}px/${y}px ${w}`, r.fillStyle = x, r.fillText(g, 0, 0), r.restore(), t.base64Url = o.toDataURL();
+        } else if (content) {
+          ctx.textBaseline = "middle";
+          ctx.textAlign = "center";
+          ctx.translate(markWidth / 2, markHeight / 2);
+          ctx.rotate(Math.PI / 180 * Number(rotate));
+          const markSize = Number(fontSize) * ratio;
+          ctx.font = `${fontStyle} normal ${fontWeight} ${markSize}px/${markHeight}px ${fontFamily}`;
+          ctx.fillStyle = fontColor;
+          ctx.fillText(content, 0, 0);
+          ctx.restore();
+          state.base64Url = canvas.toDataURL();
         }
-      } else
+      } else {
         throw new Error("当前环境不支持Canvas");
+      }
     };
-    N(), F(
+    init();
+    watch(
       () => [
-        h,
-        l,
-        s,
-        m,
-        c,
-        u,
-        f,
-        d,
-        p,
-        g,
-        b,
-        S,
-        x,
-        $,
-        w
+        zIndex,
+        gapX,
+        gapY,
+        width,
+        height,
+        rotate,
+        image,
+        imageWidth,
+        imageHeight,
+        content,
+        fontStyle,
+        fontWeight,
+        fontColor,
+        fontSize,
+        fontFamily
       ],
       () => {
-        N();
+        init();
       }
     );
-    const P = X(() => {
-      const o = q;
+    const classes = computed(() => {
+      const prefixCls = componentName;
       return {
-        [o]: !0,
-        [`${o}-full-page`]: e.fullPage
+        [prefixCls]: true,
+        [`${prefixCls}-full-page`]: props.fullPage
       };
     });
-    return C(v({}, D(t)), { classes: P });
+    return __spreadProps(__spreadValues({}, toRefs(state)), { classes });
   }
 });
-function K(e, a, t, h, l, s) {
-  return L(), M("view", {
-    class: Y(e.classes),
-    style: O({
-      zIndex: e.zIndex,
-      backgroundSize: `${e.gapX + e.width}px`,
-      backgroundImage: `url('${e.base64Url}')`
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes),
+    style: normalizeStyle({
+      zIndex: _ctx.zIndex,
+      backgroundSize: `${_ctx.gapX + _ctx.width}px`,
+      backgroundImage: `url('${_ctx.base64Url}')`
     })
   }, null, 6);
 }
-const ae = /* @__PURE__ */ j(J, [["render", K]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  ae as default
+  index as default
 };

package/dist/packages/_es/_plugin-vue_export-helper-cc2b3d55.js

@@ -0,0 +1,10 @@
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+export {
+  _export_sfc as _
+};

package/dist/packages/_es/common-b9a5e726.js

@@ -0,0 +1,145 @@
+import { shallowReactive, getCurrentInstance, provide, markRaw, isVNode, computed, h } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { p as pxCheck } from "./pxCheck-c6b9f6b7.js";
+function flattenVNodes(children, childName) {
+  const result = [];
+  const traverse = (children2) => {
+    if (!Array.isArray(children2))
+      return;
+    children2.forEach((child) => {
+      var _a;
+      if (!isVNode(child))
+        return;
+      if (childName) {
+        if (child.type && child.type.name === childName) {
+          result.push(child);
+          return;
+        }
+      } else {
+        result.push(child);
+      }
+      if ((_a = child.component) == null ? void 0 : _a.subTree) {
+        traverse(child.component.subTree.children);
+      }
+      if (child.children) {
+        traverse(child.children);
+      }
+    });
+  };
+  traverse(children);
+  return result;
+}
+function sortChildren(parent, internalChildren, childName) {
+  const vnodes = flattenVNodes(parent.subTree.children, childName);
+  internalChildren.sort((a, b) => {
+    return vnodes.indexOf(a.vnode) - vnodes.indexOf(b.vnode);
+  });
+}
+function useProvide(key, childName) {
+  const internalChildren = shallowReactive([]);
+  const parent = getCurrentInstance();
+  const add = (child) => {
+    if (!child.proxy)
+      return;
+    internalChildren.push(markRaw(child));
+    sortChildren(parent, internalChildren, childName);
+  };
+  const remove = (child) => {
+    internalChildren.splice(internalChildren.indexOf(markRaw(child)), 1);
+  };
+  const extend = Object.assign;
+  return (value) => {
+    provide(
+      key,
+      extend(
+        {
+          add,
+          remove,
+          internalChildren
+        },
+        value
+      )
+    );
+    return {
+      internalChildren
+    };
+  };
+}
+const { componentName } = createComponent("grid");
+const GRID_KEY = Symbol("grid");
+const gridProps = {
+  // 列数
+  columnNum: {
+    type: [Number, String],
+    default: 4
+  },
+  // 是否显示边框
+  border: {
+    type: Boolean,
+    default: true
+  },
+  // 格子之间间隔距离
+  gutter: {
+    type: [Number, String],
+    default: 0
+  },
+  // 是否内容居中
+  center: {
+    type: Boolean,
+    default: true
+  },
+  // 是否固定正方形
+  square: {
+    type: Boolean,
+    default: false
+  },
+  // 内容与文字翻转
+  reverse: {
+    type: Boolean,
+    default: false
+  },
+  // 内容排列方向
+  direction: {
+    type: String
+  },
+  // 是否开启点击反馈
+  clickable: {
+    type: Boolean,
+    default: false
+  }
+};
+const component = {
+  props: gridProps,
+  setup(props, { slots }) {
+    useProvide(GRID_KEY, `${componentName}-item`)({ props });
+    const rootClass = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true,
+        [`${prefixCls}--border`]: props.border && !props.gutter
+      };
+    });
+    const rootStyle = computed(() => {
+      const style = {};
+      if (props.gutter) {
+        style.paddingLeft = pxCheck(props.gutter);
+      }
+      return style;
+    });
+    return () => {
+      var _a;
+      return h(
+        "view",
+        {
+          class: rootClass.value,
+          style: rootStyle.value
+        },
+        (_a = slots.default) == null ? void 0 : _a.call(slots)
+      );
+    };
+  }
+};
+export {
+  GRID_KEY as G,
+  component as c
+};

package/dist/packages/_es/component-81a4c1d0.js

@@ -0,0 +1,145 @@
+import { defineComponent } from "vue";
+import locale from "../locale/lang";
+const TypeOfFun = (value) => {
+  if (null === value) {
+    return "null";
+  }
+  const type = typeof value;
+  if ("undefined" === type || "string" === type) {
+    return type;
+  }
+  const typeString = toString.call(value);
+  switch (typeString) {
+    case "[object Array]":
+      return "array";
+    case "[object Date]":
+      return "date";
+    case "[object Boolean]":
+      return "boolean";
+    case "[object Number]":
+      return "number";
+    case "[object Function]":
+      return "function";
+    case "[object RegExp]":
+      return "regexp";
+    case "[object Object]":
+      if (void 0 !== value.nodeType) {
+        if (3 == value.nodeType) {
+          return /\S/.test(value.nodeValue) ? "textnode" : "whitespace";
+        } else {
+          return "element";
+        }
+      } else {
+        return "object";
+      }
+    default:
+      return "unknow";
+  }
+};
+const isArray = Array.isArray;
+const isDate = (val) => val instanceof Date;
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const docu = document;
+const body = docu.body;
+const getPropByPath = (obj, keyPath) => {
+  try {
+    return keyPath.split(".").reduce((prev, curr) => prev[curr], obj);
+  } catch (error) {
+    return "";
+  }
+};
+const floatData = (format, dataOp, mapOps) => {
+  let mergeFormat = Object.assign({}, format);
+  let mergeMapOps = Object.assign({}, mapOps);
+  if (Object.keys(dataOp).length > 0) {
+    Object.keys(mergeFormat).forEach((keys) => {
+      if (mergeMapOps.hasOwnProperty(keys)) {
+        const tof = TypeOfFun(mergeMapOps[keys]);
+        if (tof == "function") {
+          mergeFormat[keys] = mergeMapOps[keys](dataOp);
+        }
+        if (tof == "string") {
+          mergeFormat[keys] = dataOp[mergeMapOps[keys]];
+        }
+      } else {
+        if (dataOp[keys])
+          mergeFormat[keys] = dataOp[keys];
+      }
+    });
+    return mergeFormat;
+  }
+  return format;
+};
+function myFixed(num, digit = 2) {
+  if (Object.is(parseFloat(num), NaN)) {
+    return console.log(`传入的值：${num}不是一个数字`);
+  }
+  num = parseFloat(num);
+  return (Math.round((num + Number.EPSILON) * Math.pow(10, digit)) / Math.pow(10, digit)).toFixed(digit);
+}
+function preventDefault(event, isStopPropagation) {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    event.stopPropagation();
+  }
+}
+const padZero = (num, length = 2) => {
+  num += "";
+  while (num.length < length) {
+    num = "0" + num;
+  }
+  return num.toString();
+};
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+const getScrollTopRoot = () => {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+};
+function createComponent(name) {
+  const componentName = "nut-" + name;
+  return {
+    componentName,
+    translate(keyPath, ...args) {
+      const languages = locale.languages();
+      const text = getPropByPath(languages, `${name.replace("-", "")}.${keyPath}`) || getPropByPath(languages, keyPath);
+      return isFunction(text) ? text(...args) : text;
+    },
+    create: function(_component) {
+      _component.baseName = name;
+      _component.name = componentName;
+      _component.install = (vue) => {
+        vue.component(_component.name, _component);
+      };
+      return defineComponent(_component);
+    },
+    createDemo: function(_component) {
+      _component.baseName = name;
+      _component.name = "demo-" + name;
+      return defineComponent(_component);
+    }
+  };
+}
+export {
+  TypeOfFun as T,
+  isDate as a,
+  body as b,
+  createComponent as c,
+  preventDefault as d,
+  clamp as e,
+  isPromise as f,
+  isObject as g,
+  getPropByPath as h,
+  isArray as i,
+  isString as j,
+  isFunction as k,
+  getScrollTopRoot as l,
+  myFixed as m,
+  floatData as n,
+  padZero as p
+};

package/dist/packages/_es/index-29892cda.js

@@ -0,0 +1,33 @@
+import { unref } from "vue";
+function isWindow(val) {
+  return val === window;
+}
+const useRect = (elementRef) => {
+  const element = unref(elementRef);
+  if (isWindow(element)) {
+    const width = element.innerWidth;
+    const height = element.innerHeight;
+    return {
+      top: 0,
+      left: 0,
+      right: width,
+      bottom: height,
+      width,
+      height
+    };
+  }
+  if (element && element.getBoundingClientRect) {
+    return element.getBoundingClientRect();
+  }
+  return {
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    width: 0,
+    height: 0
+  };
+};
+export {
+  useRect as u
+};

package/dist/packages/_es/index-43c34ac6.js

@@ -0,0 +1,30 @@
+import { ref, onMounted } from "vue";
+const overflowScrollReg = /scroll|auto|overlay/i;
+const defaultRoot = window;
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === ELEMENT_NODE_TYPE;
+}
+function getScrollParent(el, root = defaultRoot) {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}
+function useScrollParent(el, root = defaultRoot) {
+  const scrollParent = ref();
+  onMounted(() => {
+    if (el.value) {
+      scrollParent.value = getScrollParent(el.value, root);
+    }
+  });
+  return scrollParent;
+}
+export {
+  useScrollParent as u
+};

package/dist/packages/_es/index-54d03fc1.js

@@ -0,0 +1,8 @@
+import { getCurrentInstance } from "vue";
+function useRouter() {
+  const proxy = getCurrentInstance().proxy;
+  return proxy.$router || null;
+}
+export {
+  useRouter as u
+};

package/dist/packages/_es/index-79c5dc33.js

@@ -0,0 +1,10 @@
+import { getCurrentInstance } from "vue";
+function useExpose(apis) {
+  const instance = getCurrentInstance();
+  if (instance) {
+    Object.assign(instance.proxy, apis);
+  }
+}
+export {
+  useExpose as u
+};

package/dist/packages/_es/index-7a7385e4.js

@@ -0,0 +1,67 @@
+import { ref } from "vue";
+const MIN_DISTANCE = 10;
+function getDirection(x, y) {
+  if (x > y && x > MIN_DISTANCE) {
+    return "horizontal";
+  }
+  if (y > x && y > MIN_DISTANCE) {
+    return "vertical";
+  }
+  return "";
+}
+function useTouch() {
+  const startX = ref(0);
+  const startY = ref(0);
+  const moveX = ref(0);
+  const moveY = ref(0);
+  const deltaX = ref(0);
+  const deltaY = ref(0);
+  const offsetX = ref(0);
+  const offsetY = ref(0);
+  const direction = ref("");
+  const isVertical = () => direction.value === "vertical";
+  const isHorizontal = () => direction.value === "horizontal";
+  const reset = () => {
+    deltaX.value = 0;
+    deltaY.value = 0;
+    offsetX.value = 0;
+    offsetY.value = 0;
+    direction.value = "";
+  };
+  const start = (event) => {
+    reset();
+    startX.value = event.touches[0].clientX;
+    startY.value = event.touches[0].clientY;
+  };
+  const move = (event) => {
+    const touch = event.touches[0];
+    deltaX.value = touch.clientX - startX.value;
+    deltaY.value = touch.clientY - startY.value;
+    moveX.value = touch.clientX;
+    moveY.value = touch.clientY;
+    offsetX.value = Math.abs(deltaX.value);
+    offsetY.value = Math.abs(deltaY.value);
+    if (!direction.value) {
+      direction.value = getDirection(offsetX.value, offsetY.value);
+    }
+  };
+  return {
+    move,
+    start,
+    reset,
+    startX,
+    startY,
+    moveX,
+    moveY,
+    deltaX,
+    deltaY,
+    offsetX,
+    offsetY,
+    direction,
+    isVertical,
+    isHorizontal
+  };
+}
+export {
+  useTouch as u
+};