vant 2.13.2 → 2.13.3

package/lib/vue-sfc-shim.d.ts

@@ -0,0 +1,6 @@
+declare module '*.vue' {
+  // eslint-disable-next-line
+  import { DefineComponent } from 'vue';
+  const Component: DefineComponent;
+  export default Component;
+}

package/lib/vue-tsx-shim.d.ts

@@ -0,0 +1,24 @@
+import 'vue';
+
+type EventHandler = (...args: any[]) => void;
+
+declare module 'vue' {
+  interface ComponentCustomProps {
+    id?: string;
+    role?: string;
+    tabindex?: number;
+    onClick?: EventHandler;
+    onTouchend?: EventHandler;
+    onTouchmove?: EventHandler;
+    onTouchstart?: EventHandler;
+    onTouchcancel?: EventHandler;
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
+  }
+
+  interface HTMLAttributes {
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
+    onClickCapture?: EventHandler;
+  }
+}

package/lib/watermark/Watermark.d.ts

@@ -0,0 +1,112 @@
+import { type ExtractPropTypes } from 'vue';
+export declare const watermarkProps: {
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+    image: StringConstructor;
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rotate: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    content: StringConstructor;
+    opacity: (NumberConstructor | StringConstructor)[];
+    fullPage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    textColor: {
+        type: import("vue").PropType<T>;
+        default: string;
+    };
+};
+export type WatermarkProps = ExtractPropTypes<typeof watermarkProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+    image: StringConstructor;
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rotate: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    content: StringConstructor;
+    opacity: (NumberConstructor | StringConstructor)[];
+    fullPage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    textColor: {
+        type: import("vue").PropType<T>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+    image: StringConstructor;
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rotate: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    content: StringConstructor;
+    opacity: (NumberConstructor | StringConstructor)[];
+    fullPage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    textColor: {
+        type: import("vue").PropType<T>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    width: number;
+    height: number;
+    textColor: string;
+    rotate: string | number;
+    gapX: number;
+    gapY: number;
+    fullPage: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/watermark/Watermark.js

@@ -0,0 +1,151 @@
+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,
+  watermarkProps: () => watermarkProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+const [name, bem] = (0, import_utils.createNamespace)("watermark");
+const watermarkProps = {
+  gapX: (0, import_utils.makeNumberProp)(0),
+  gapY: (0, import_utils.makeNumberProp)(0),
+  image: String,
+  width: (0, import_utils.makeNumberProp)(100),
+  height: (0, import_utils.makeNumberProp)(100),
+  rotate: (0, import_utils.makeNumericProp)(-22),
+  zIndex: import_utils.numericProp,
+  content: String,
+  opacity: import_utils.numericProp,
+  fullPage: import_utils.truthProp,
+  textColor: (0, import_utils.makeStringProp)("#dcdee0")
+};
+var stdin_default = (0, import_vue.defineComponent)({
+  name,
+  props: watermarkProps,
+  setup(props, {
+    slots
+  }) {
+    const svgElRef = (0, import_vue.ref)();
+    const watermarkUrl = (0, import_vue.ref)("");
+    const imageBase64 = (0, import_vue.ref)("");
+    const renderWatermark = () => {
+      const rotateStyle = {
+        transformOrigin: "center",
+        transform: `rotate(${props.rotate}deg)`
+      };
+      const svgInner = () => {
+        if (props.image && !slots.content) {
+          return (0, import_vue.createVNode)("image", {
+            "href": imageBase64.value,
+            "xlink:href": imageBase64.value,
+            "x": "0",
+            "y": "0",
+            "width": props.width,
+            "height": props.height,
+            "style": rotateStyle
+          }, null);
+        }
+        return (0, import_vue.createVNode)("foreignObject", {
+          "x": "0",
+          "y": "0",
+          "width": props.width,
+          "height": props.height
+        }, [(0, import_vue.createVNode)("div", {
+          "xmlns": "http://www.w3.org/1999/xhtml",
+          "style": rotateStyle
+        }, [slots.content ? slots.content() : (0, import_vue.createVNode)("span", {
+          "style": {
+            color: props.textColor
+          }
+        }, [props.content])])]);
+      };
+      const svgWidth = props.width + props.gapX;
+      const svgHeight = props.height + props.gapY;
+      return (0, import_vue.createVNode)("svg", {
+        "viewBox": `0 0 ${svgWidth} ${svgHeight}`,
+        "width": svgWidth,
+        "height": svgHeight,
+        "xmlns": "http://www.w3.org/2000/svg",
+        "xmlns:xlink": "http://www.w3.org/1999/xlink",
+        "style": {
+          padding: `0 ${props.gapX}px ${props.gapY}px 0`,
+          opacity: props.opacity
+        }
+      }, [svgInner()]);
+    };
+    const makeImageToBase64 = (url) => {
+      const canvas = document.createElement("canvas");
+      const image = new Image();
+      image.crossOrigin = "anonymous";
+      image.referrerPolicy = "no-referrer";
+      image.onload = () => {
+        canvas.width = image.naturalWidth;
+        canvas.height = image.naturalHeight;
+        const ctx = canvas.getContext("2d");
+        ctx == null ? void 0 : ctx.drawImage(image, 0, 0);
+        imageBase64.value = canvas.toDataURL();
+      };
+      image.src = url;
+    };
+    const makeSvgToBlobUrl = (svgStr) => {
+      const svgBlob = new Blob([svgStr], {
+        type: "image/svg+xml"
+      });
+      return URL.createObjectURL(svgBlob);
+    };
+    (0, import_vue.watchEffect)(() => {
+      if (props.image) {
+        makeImageToBase64(props.image);
+      }
+    });
+    (0, import_vue.watch)(() => [imageBase64.value, props.content, props.textColor, props.height, props.width, props.rotate, props.gapX, props.gapY], () => {
+      (0, import_vue.nextTick)(() => {
+        if (svgElRef.value) {
+          if (watermarkUrl.value) {
+            URL.revokeObjectURL(watermarkUrl.value);
+          }
+          watermarkUrl.value = makeSvgToBlobUrl(svgElRef.value.innerHTML);
+        }
+      });
+    }, {
+      immediate: true
+    });
+    (0, import_vue.onUnmounted)(() => {
+      if (watermarkUrl.value) {
+        URL.revokeObjectURL(watermarkUrl.value);
+      }
+    });
+    return () => {
+      const style = (0, import_utils.extend)({
+        backgroundImage: `url(${watermarkUrl.value})`
+      }, (0, import_utils.getZIndexStyle)(props.zIndex));
+      return (0, import_vue.createVNode)("div", {
+        "class": bem({
+          full: props.fullPage
+        }),
+        "style": style
+      }, [(0, import_vue.createVNode)("div", {
+        "class": bem("wrapper"),
+        "ref": svgElRef
+      }, [renderWatermark()])]);
+    };
+  }
+});

package/lib/watermark/index.css

@@ -0,0 +1 @@
+:root,:host{--van-watermark-z-index: 100}.van-watermark{position:absolute;height:100%;width:100%;left:0;top:0;z-index:var(--van-watermark-z-index);background-repeat:repeat;pointer-events:none}.van-watermark__wrapper{display:none}.van-watermark--full{position:fixed}

package/lib/watermark/index.d.ts

@@ -0,0 +1,84 @@
+export declare const Watermark: import("../utils").WithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+    image: StringConstructor;
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rotate: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    content: StringConstructor;
+    opacity: (NumberConstructor | StringConstructor)[];
+    fullPage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    textColor: {
+        type: import("vue").PropType<T>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+    image: StringConstructor;
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rotate: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    content: StringConstructor;
+    opacity: (NumberConstructor | StringConstructor)[];
+    fullPage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    textColor: {
+        type: import("vue").PropType<T>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    width: number;
+    height: number;
+    textColor: string;
+    rotate: string | number;
+    gapX: number;
+    gapY: number;
+    fullPage: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default Watermark;
+export { watermarkProps } from './Watermark';
+export type { WatermarkProps } from './Watermark';
+export type { WatermarkThemeVars } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanWatermark: typeof Watermark;
+    }
+}

package/lib/watermark/index.js

@@ -0,0 +1,39 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Watermark: () => Watermark,
+  default: () => stdin_default,
+  watermarkProps: () => import_Watermark2.watermarkProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_Watermark = __toESM(require("./Watermark"));
+var import_Watermark2 = require("./Watermark");
+const Watermark = (0, import_utils.withInstall)(import_Watermark.default);
+var stdin_default = Watermark;

package/lib/watermark/style/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/watermark/style/index.js

@@ -0,0 +1,2 @@
+require("../../style/base.css");
+require("../index.css");

package/lib/watermark/types.d.ts

@@ -0,0 +1,3 @@
+export type WatermarkThemeVars = {
+    watermarkZIndex?: number | string;
+};

package/lib/watermark/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = {};
+module.exports = __toCommonJS(stdin_exports);