vant 4.0.5 → 4.0.6

package/lib/utils/format.js

@@ -0,0 +1,139 @@
+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, {
+  addNumber: () => addNumber,
+  addUnit: () => addUnit,
+  camelize: () => camelize,
+  clamp: () => clamp,
+  formatNumber: () => formatNumber,
+  getSizeStyle: () => getSizeStyle,
+  getZIndexStyle: () => getZIndexStyle,
+  kebabCase: () => kebabCase,
+  padZero: () => padZero,
+  unitToPx: () => unitToPx
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+var import_dom = require("./dom");
+var import_validate = require("./validate");
+function addUnit(value) {
+  if ((0, import_validate.isDef)(value)) {
+    return (0, import_validate.isNumeric)(value) ? `${value}px` : String(value);
+  }
+  return void 0;
+}
+function getSizeStyle(originSize) {
+  if ((0, import_validate.isDef)(originSize)) {
+    if (Array.isArray(originSize)) {
+      return {
+        width: addUnit(originSize[0]),
+        height: addUnit(originSize[1])
+      };
+    }
+    const size = addUnit(originSize);
+    return {
+      width: size,
+      height: size
+    };
+  }
+}
+function getZIndexStyle(zIndex) {
+  const style = {};
+  if (zIndex !== void 0) {
+    style.zIndex = +zIndex;
+  }
+  return style;
+}
+let rootFontSize;
+function getRootFontSize() {
+  if (!rootFontSize) {
+    const doc = document.documentElement;
+    const fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+    rootFontSize = parseFloat(fontSize);
+  }
+  return rootFontSize;
+}
+function convertRem(value) {
+  value = value.replace(/rem/g, "");
+  return +value * getRootFontSize();
+}
+function convertVw(value) {
+  value = value.replace(/vw/g, "");
+  return +value * import_dom.windowWidth.value / 100;
+}
+function convertVh(value) {
+  value = value.replace(/vh/g, "");
+  return +value * import_dom.windowHeight.value / 100;
+}
+function unitToPx(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (import_basic.inBrowser) {
+    if (value.includes("rem")) {
+      return convertRem(value);
+    }
+    if (value.includes("vw")) {
+      return convertVw(value);
+    }
+    if (value.includes("vh")) {
+      return convertVh(value);
+    }
+  }
+  return parseFloat(value);
+}
+const camelizeRE = /-(\w)/g;
+const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
+const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+function padZero(num, targetLength = 2) {
+  let str = num + "";
+  while (str.length < targetLength) {
+    str = "0" + str;
+  }
+  return str;
+}
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+function trimExtraChar(value, char, regExp) {
+  const index = value.indexOf(char);
+  if (index === -1) {
+    return value;
+  }
+  if (char === "-" && index !== 0) {
+    return value.slice(0, index);
+  }
+  return value.slice(0, index + 1) + value.slice(index).replace(regExp, "");
+}
+function formatNumber(value, allowDot = true, allowMinus = true) {
+  if (allowDot) {
+    value = trimExtraChar(value, ".", /\./g);
+  } else {
+    value = value.split(".")[0];
+  }
+  if (allowMinus) {
+    value = trimExtraChar(value, "-", /-/g);
+  } else {
+    value = value.replace(/-/, "");
+  }
+  const regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+  return value.replace(regExp, "");
+}
+function addNumber(num1, num2) {
+  const cardinal = 10 ** 10;
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}

package/lib/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './basic';
+export * from './props';
+export * from './dom';
+export * from './create';
+export * from './format';
+export * from './constant';
+export * from './validate';
+export * from './interceptor';
+export * from './with-install';

package/lib/utils/index.js

@@ -0,0 +1,25 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);
+__reExport(stdin_exports, require("./basic"), module.exports);
+__reExport(stdin_exports, require("./props"), module.exports);
+__reExport(stdin_exports, require("./dom"), module.exports);
+__reExport(stdin_exports, require("./create"), module.exports);
+__reExport(stdin_exports, require("./format"), module.exports);
+__reExport(stdin_exports, require("./constant"), module.exports);
+__reExport(stdin_exports, require("./validate"), module.exports);
+__reExport(stdin_exports, require("./interceptor"), module.exports);
+__reExport(stdin_exports, require("./with-install"), module.exports);

package/lib/utils/interceptor.d.ts

@@ -0,0 +1,6 @@
+export type Interceptor = (...args: any[]) => Promise<boolean> | boolean | undefined | void;
+export declare function callInterceptor(interceptor: Interceptor | undefined, { args, done, canceled, }: {
+    args?: unknown[];
+    done: () => void;
+    canceled?: () => void;
+}): void;

package/lib/utils/interceptor.js

@@ -0,0 +1,48 @@
+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, {
+  callInterceptor: () => callInterceptor
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+var import_validate = require("./validate");
+function callInterceptor(interceptor, {
+  args = [],
+  done,
+  canceled
+}) {
+  if (interceptor) {
+    const returnVal = interceptor.apply(null, args);
+    if ((0, import_validate.isPromise)(returnVal)) {
+      returnVal.then((value) => {
+        if (value) {
+          done();
+        } else if (canceled) {
+          canceled();
+        }
+      }).catch(import_basic.noop);
+    } else if (returnVal) {
+      done();
+    } else if (canceled) {
+      canceled();
+    }
+  } else {
+    done();
+  }
+}

package/lib/utils/mount-component.d.ts

@@ -0,0 +1,14 @@
+import { Component } from 'vue';
+export declare function usePopupState(): {
+    open: (props: Record<string, any>) => void;
+    close: () => void;
+    state: {
+        [x: string]: any;
+        show: boolean;
+    };
+    toggle: (show: boolean) => void;
+};
+export declare function mountComponent(RootComponent: Component): {
+    instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+    unmount(): void;
+};

package/lib/utils/mount-component.js

@@ -0,0 +1,58 @@
+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, {
+  mountComponent: () => mountComponent,
+  usePopupState: () => usePopupState
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_basic = require("./basic");
+var import_use_expose = require("../composables/use-expose");
+function usePopupState() {
+  const state = (0, import_vue.reactive)({
+    show: false
+  });
+  const toggle = (show) => {
+    state.show = show;
+  };
+  const open = (props) => {
+    (0, import_basic.extend)(state, props, { transitionAppear: true });
+    toggle(true);
+  };
+  const close = () => toggle(false);
+  (0, import_use_expose.useExpose)({ open, close, toggle });
+  return {
+    open,
+    close,
+    state,
+    toggle
+  };
+}
+function mountComponent(RootComponent) {
+  const app = (0, import_vue.createApp)(RootComponent);
+  const root = document.createElement("div");
+  document.body.appendChild(root);
+  return {
+    instance: app.mount(root),
+    unmount() {
+      app.unmount();
+      document.body.removeChild(root);
+    }
+  };
+}

package/lib/utils/props.d.ts

@@ -0,0 +1,31 @@
+/**
+ * prop type helpers
+ * help us to write less code and reduce bundle size
+ */
+import type { PropType } from 'vue';
+export declare const unknownProp: PropType<unknown>;
+export declare const numericProp: (NumberConstructor | StringConstructor)[];
+export declare const truthProp: {
+    type: BooleanConstructor;
+    default: true;
+};
+export declare const makeRequiredProp: <T>(type: T) => {
+    type: T;
+    required: true;
+};
+export declare const makeArrayProp: <T>() => {
+    type: PropType<T[]>;
+    default: () => never[];
+};
+export declare const makeNumberProp: <T>(defaultVal: T) => {
+    type: NumberConstructor;
+    default: T;
+};
+export declare const makeNumericProp: <T>(defaultVal: T) => {
+    type: (NumberConstructor | StringConstructor)[];
+    default: T;
+};
+export declare const makeStringProp: <T>(defaultVal: T) => {
+    type: PropType<T>;
+    default: T;
+};

package/lib/utils/props.js

@@ -0,0 +1,55 @@
+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, {
+  makeArrayProp: () => makeArrayProp,
+  makeNumberProp: () => makeNumberProp,
+  makeNumericProp: () => makeNumericProp,
+  makeRequiredProp: () => makeRequiredProp,
+  makeStringProp: () => makeStringProp,
+  numericProp: () => numericProp,
+  truthProp: () => truthProp,
+  unknownProp: () => unknownProp
+});
+module.exports = __toCommonJS(stdin_exports);
+const unknownProp = null;
+const numericProp = [Number, String];
+const truthProp = {
+  type: Boolean,
+  default: true
+};
+const makeRequiredProp = (type) => ({
+  type,
+  required: true
+});
+const makeArrayProp = () => ({
+  type: Array,
+  default: () => []
+});
+const makeNumberProp = (defaultVal) => ({
+  type: Number,
+  default: defaultVal
+});
+const makeNumericProp = (defaultVal) => ({
+  type: numericProp,
+  default: defaultVal
+});
+const makeStringProp = (defaultVal) => ({
+  type: String,
+  default: defaultVal
+});

package/lib/utils/validate.d.ts

@@ -0,0 +1,9 @@
+import { type Numeric } from './basic';
+export declare const isDef: <T>(val: T) => val is NonNullable<T>;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+export declare const isDate: (val: unknown) => val is Date;
+export declare function isMobile(value: string): boolean;
+export declare const isNumeric: (val: Numeric) => val is string;
+export declare const isIOS: () => boolean;

package/lib/utils/validate.js

@@ -0,0 +1,41 @@
+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, {
+  isDate: () => isDate,
+  isDef: () => isDef,
+  isFunction: () => isFunction,
+  isIOS: () => isIOS,
+  isMobile: () => isMobile,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+const isDef = (val) => val !== void 0 && val !== null;
+const isFunction = (val) => typeof val === "function";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
+const isDate = (val) => Object.prototype.toString.call(val) === "[object Date]" && !Number.isNaN(val.getTime());
+function isMobile(value) {
+  value = value.replace(/[^-|\d]/g, "");
+  return /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value);
+}
+const isNumeric = (val) => typeof val === "number" || /^\d+(\.\d+)?$/.test(val);
+const isIOS = () => import_basic.inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;

package/lib/utils/with-install.d.ts

@@ -0,0 +1,13 @@
+import type { App, Component } from 'vue';
+type EventShim = {
+    new (...args: any[]): {
+        $props: {
+            onClick?: (...args: any[]) => void;
+        };
+    };
+};
+export type WithInstall<T> = T & {
+    install(app: App): void;
+} & EventShim;
+export declare function withInstall<T extends Component>(options: T): WithInstall<T>;
+export {};

package/lib/utils/with-install.js

@@ -0,0 +1,33 @@
+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, {
+  withInstall: () => withInstall
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_format = require("./format");
+function withInstall(options) {
+  options.install = (app) => {
+    const { name } = options;
+    if (name) {
+      app.component(name, options);
+      app.component((0, import_format.camelize)(`-${name}`), options);
+    }
+  };
+  return options;
+}

package/lib/vant.cjs.js

@@ -14899,7 +14899,7 @@ const Lazyload = {
     });
   }
 };
-const version = "4.0.5";
+const version = "4.0.6";
 function install(app) {
   const components = [
     ActionBar,

package/lib/vant.es.js

@@ -14897,7 +14897,7 @@ const Lazyload = {
     });
   }
 };
-const version = "4.0.5";
+const version = "4.0.6";
 function install(app) {
   const components = [
     ActionBar,

package/lib/vant.js

@@ -16105,7 +16105,7 @@
       });
     }
   };
-  const version = "4.0.5";
+  const version = "4.0.6";
   function install(app) {
     const components = [
       ActionBar,