vant 2.13.2 → 2.13.3

package/lib/utils/dom.js

@@ -0,0 +1,103 @@
+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, {
+  getContainingBlock: () => getContainingBlock,
+  getElementTop: () => getElementTop,
+  getRootScrollTop: () => getRootScrollTop,
+  getScrollTop: () => getScrollTop,
+  isHidden: () => isHidden,
+  preventDefault: () => preventDefault,
+  resetScroll: () => resetScroll,
+  setRootScrollTop: () => setRootScrollTop,
+  setScrollTop: () => setScrollTop,
+  stopPropagation: () => stopPropagation,
+  windowHeight: () => windowHeight,
+  windowWidth: () => windowWidth
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_use = require("@vant/use");
+var import_vue = require("vue");
+var import_basic = require("./basic");
+function getScrollTop(el) {
+  const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+  return Math.max(top, 0);
+}
+function setScrollTop(el, value) {
+  if ("scrollTop" in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+function getRootScrollTop() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+function setRootScrollTop(value) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+}
+function getElementTop(el, scroller) {
+  if (el === window) {
+    return 0;
+  }
+  const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return (0, import_use.useRect)(el).top + scrollTop;
+}
+const isIOS = (0, import_basic.isIOS)();
+function resetScroll() {
+  if (isIOS) {
+    setRootScrollTop(getRootScrollTop());
+  }
+}
+const stopPropagation = (event) => event.stopPropagation();
+function preventDefault(event, isStopPropagation) {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}
+function isHidden(elementRef) {
+  const el = (0, import_vue.unref)(elementRef);
+  if (!el) {
+    return false;
+  }
+  const style = window.getComputedStyle(el);
+  const hidden = style.display === "none";
+  const parentHidden = el.offsetParent === null && style.position !== "fixed";
+  return hidden || parentHidden;
+}
+const { width: windowWidth, height: windowHeight } = (0, import_use.useWindowSize)();
+function isContainingBlock(el) {
+  const css = window.getComputedStyle(el);
+  return css.transform !== "none" || css.perspective !== "none" || ["transform", "perspective", "filter"].some(
+    (value) => (css.willChange || "").includes(value)
+  );
+}
+function getContainingBlock(el) {
+  let node = el.parentElement;
+  while (node) {
+    if (node && node.tagName !== "HTML" && node.tagName !== "BODY" && isContainingBlock(node)) {
+      return node;
+    }
+    node = node.parentElement;
+  }
+  return null;
+}

package/lib/utils/format.d.ts

@@ -0,0 +1,13 @@
+import type { CSSProperties } from 'vue';
+import { type Numeric } from './basic';
+export declare function addUnit(value?: Numeric): string | undefined;
+export declare function getSizeStyle(originSize?: Numeric | Numeric[]): CSSProperties | undefined;
+export declare function getZIndexStyle(zIndex?: Numeric): CSSProperties;
+export declare function unitToPx(value: Numeric): number;
+export declare const camelize: (str: string) => string;
+export declare const kebabCase: (str: string) => string;
+export declare function padZero(num: Numeric, targetLength?: number): string;
+/** clamps number within the inclusive lower and upper bounds */
+export declare const clamp: (num: number, min: number, max: number) => number;
+export declare function formatNumber(value: string, allowDot?: boolean, allowMinus?: boolean): string;
+export declare function addNumber(num1: number, num2: number): number;

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_basic2 = require("./basic");
+function addUnit(value) {
+  if ((0, import_basic2.isDef)(value)) {
+    return (0, import_basic2.isNumeric)(value) ? `${value}px` : String(value);
+  }
+  return void 0;
+}
+function getSizeStyle(originSize) {
+  if ((0, import_basic2.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 './interceptor';
+export * from './with-install';
+export * from './closest';

package/lib/utils/index.js

@@ -1,100 +1,25 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.noop = noop;
-exports.isDef = isDef;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isPromise = isPromise;
-exports.get = get;
-exports.isEmpty = isEmpty;
-exports.isServer = exports.inBrowser = exports.addUnit = exports.createNamespace = void 0;
-
-var _vue = _interopRequireDefault(require("vue"));
-
-var _create = require("./create");
-
-exports.createNamespace = _create.createNamespace;
-
-var _unit = require("./format/unit");
-
-exports.addUnit = _unit.addUnit;
-var inBrowser = typeof window !== 'undefined';
-exports.inBrowser = inBrowser;
-var isServer = _vue.default.prototype.$isServer; // eslint-disable-next-line @typescript-eslint/no-empty-function
-
-exports.isServer = isServer;
-
-function noop() {}
-
-function isDef(val) {
-  return val !== undefined && val !== null;
-}
-
-function isFunction(val) {
-  return typeof val === 'function';
-}
-
-function isObject(val) {
-  return val !== null && typeof val === 'object';
-}
-
-function isPromise(val) {
-  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
-}
-
-function get(object, path) {
-  var keys = path.split('.');
-  var result = object;
-  keys.forEach(function (key) {
-    var _result$key;
-
-    result = isObject(result) ? (_result$key = result[key]) != null ? _result$key : '' : '';
-  });
-  return result;
-}
-/**
- * Checks if `value` is an empty object, collection, map, or set.
- *
- * Objects are considered empty if they have no own enumerable string keyed
- * properties.
- *
- * Array-like values such as `arguments` objects, arrays, buffers, strings, or
- * jQuery-like collections are considered empty if they have a `length` of `0`.
- * Similarly, maps and sets are considered empty if they have a `size` of `0`.
- *
- * @function isEmpty
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is empty, else `false`.
- * @example
- *
- * _.isEmpty(null);
- * // => true
- *
- * _.isEmpty(true);
- * // => true
- *
- * _.isEmpty(1);
- * // => true
- *
- * _.isEmpty([1, 2, 3]);
- * // => false
- *
- * _.isEmpty({ 'a': 1 });
- * // => false
- */
-
-
-function isEmpty(value) {
-  if (value == null) {
-    return true;
+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 });
   }
-
-  if (typeof value !== 'object') {
-    return true;
-  }
-
-  return Object.keys(value).length === 0;
-}
+  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("./interceptor"), module.exports);
+__reExport(stdin_exports, require("./with-install"), module.exports);
+__reExport(stdin_exports, require("./closest"), module.exports);

package/lib/utils/interceptor.d.ts

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

package/lib/utils/interceptor.js

@@ -1,28 +1,48 @@
-"use strict";
-
-exports.__esModule = true;
-exports.callInterceptor = callInterceptor;
-
-var _ = require(".");
-
-function callInterceptor(options) {
-  var interceptor = options.interceptor,
-      args = options.args,
-      done = options.done;
-
+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");
+function callInterceptor(interceptor, {
+  args = [],
+  done,
+  canceled,
+  error
+}) {
   if (interceptor) {
-    var returnVal = interceptor.apply(void 0, args);
-
-    if ((0, _.isPromise)(returnVal)) {
-      returnVal.then(function (value) {
+    const returnVal = interceptor.apply(null, args);
+    if ((0, import_basic.isPromise)(returnVal)) {
+      returnVal.then((value) => {
         if (value) {
           done();
+        } else if (canceled) {
+          canceled();
         }
-      }).catch(_.noop);
+      }).catch(error || 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, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any>;
+    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
+});