vant 4.0.5 → 4.0.6

package/lib/lazyload/vue-lazyload/util.js

@@ -0,0 +1,185 @@
+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, {
+  ImageCache: () => ImageCache,
+  getBestSelectionFromSrcset: () => getBestSelectionFromSrcset,
+  getDPR: () => getDPR,
+  hasIntersectionObserver: () => hasIntersectionObserver,
+  loadImageAsync: () => loadImageAsync,
+  modeType: () => modeType,
+  off: () => off,
+  on: () => on,
+  remove: () => remove,
+  supportWebp: () => supportWebp,
+  throttle: () => throttle
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_use = require("@vant/use");
+const hasIntersectionObserver = import_use.inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype;
+const modeType = {
+  event: "event",
+  observer: "observer"
+};
+function remove(arr, item) {
+  if (!arr.length)
+    return;
+  const index = arr.indexOf(item);
+  if (index > -1)
+    return arr.splice(index, 1);
+}
+function getBestSelectionFromSrcset(el, scale) {
+  if (el.tagName !== "IMG" || !el.getAttribute("data-srcset"))
+    return;
+  let options = el.getAttribute("data-srcset");
+  const container = el.parentNode;
+  const containerWidth = container.offsetWidth * scale;
+  let spaceIndex;
+  let tmpSrc;
+  let tmpWidth;
+  options = options.trim().split(",");
+  const result = options.map((item) => {
+    item = item.trim();
+    spaceIndex = item.lastIndexOf(" ");
+    if (spaceIndex === -1) {
+      tmpSrc = item;
+      tmpWidth = 999998;
+    } else {
+      tmpSrc = item.substr(0, spaceIndex);
+      tmpWidth = parseInt(
+        item.substr(spaceIndex + 1, item.length - spaceIndex - 2),
+        10
+      );
+    }
+    return [tmpWidth, tmpSrc];
+  });
+  result.sort((a, b) => {
+    if (a[0] < b[0]) {
+      return 1;
+    }
+    if (a[0] > b[0]) {
+      return -1;
+    }
+    if (a[0] === b[0]) {
+      if (b[1].indexOf(".webp", b[1].length - 5) !== -1) {
+        return 1;
+      }
+      if (a[1].indexOf(".webp", a[1].length - 5) !== -1) {
+        return -1;
+      }
+    }
+    return 0;
+  });
+  let bestSelectedSrc = "";
+  let tmpOption;
+  for (let i = 0; i < result.length; i++) {
+    tmpOption = result[i];
+    bestSelectedSrc = tmpOption[1];
+    const next = result[i + 1];
+    if (next && next[0] < containerWidth) {
+      bestSelectedSrc = tmpOption[1];
+      break;
+    } else if (!next) {
+      bestSelectedSrc = tmpOption[1];
+      break;
+    }
+  }
+  return bestSelectedSrc;
+}
+const getDPR = (scale = 1) => import_use.inBrowser ? window.devicePixelRatio || scale : scale;
+function supportWebp() {
+  if (!import_use.inBrowser)
+    return false;
+  let support = true;
+  try {
+    const elem = document.createElement("canvas");
+    if (elem.getContext && elem.getContext("2d")) {
+      support = elem.toDataURL("image/webp").indexOf("data:image/webp") === 0;
+    }
+  } catch (err) {
+    support = false;
+  }
+  return support;
+}
+function throttle(action, delay) {
+  let timeout = null;
+  let lastRun = 0;
+  return function(...args) {
+    if (timeout) {
+      return;
+    }
+    const elapsed = Date.now() - lastRun;
+    const runCallback = () => {
+      lastRun = Date.now();
+      timeout = false;
+      action.apply(this, args);
+    };
+    if (elapsed >= delay) {
+      runCallback();
+    } else {
+      timeout = setTimeout(runCallback, delay);
+    }
+  };
+}
+function on(el, type, func) {
+  el.addEventListener(type, func, {
+    capture: false,
+    passive: true
+  });
+}
+function off(el, type, func) {
+  el.removeEventListener(type, func, false);
+}
+const loadImageAsync = (item, resolve, reject) => {
+  const image = new Image();
+  if (!item || !item.src) {
+    return reject(new Error("image src is required"));
+  }
+  image.src = item.src;
+  if (item.cors) {
+    image.crossOrigin = item.cors;
+  }
+  image.onload = () => resolve({
+    naturalHeight: image.naturalHeight,
+    naturalWidth: image.naturalWidth,
+    src: image.src
+  });
+  image.onerror = (e) => reject(e);
+};
+class ImageCache {
+  constructor({ max }) {
+    this.options = {
+      max: max || 100
+    };
+    this.caches = [];
+  }
+  has(key) {
+    return this.caches.indexOf(key) > -1;
+  }
+  add(key) {
+    if (this.has(key))
+      return;
+    this.caches.push(key);
+    if (this.caches.length > this.options.max) {
+      this.free();
+    }
+  }
+  free() {
+    this.caches.shift();
+  }
+}

package/lib/list/List.d.ts

@@ -0,0 +1,78 @@
+import { type ExtractPropTypes } from 'vue';
+import type { ListDirection } from './types';
+export declare const listProps: {
+    error: BooleanConstructor;
+    offset: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    loading: BooleanConstructor;
+    disabled: BooleanConstructor;
+    finished: BooleanConstructor;
+    errorText: StringConstructor;
+    direction: {
+        type: import("vue").PropType<ListDirection>;
+        default: ListDirection;
+    };
+    loadingText: StringConstructor;
+    finishedText: StringConstructor;
+    immediateCheck: {
+        type: BooleanConstructor;
+        default: true;
+    };
+};
+export type ListProps = ExtractPropTypes<typeof listProps>;
+declare const _default: import("vue").DefineComponent<{
+    error: BooleanConstructor;
+    offset: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    loading: BooleanConstructor;
+    disabled: BooleanConstructor;
+    finished: BooleanConstructor;
+    errorText: StringConstructor;
+    direction: {
+        type: import("vue").PropType<ListDirection>;
+        default: ListDirection;
+    };
+    loadingText: StringConstructor;
+    finishedText: StringConstructor;
+    immediateCheck: {
+        type: BooleanConstructor;
+        default: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("load" | "update:error" | "update:loading")[], "load" | "update:error" | "update:loading", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    error: BooleanConstructor;
+    offset: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    loading: BooleanConstructor;
+    disabled: BooleanConstructor;
+    finished: BooleanConstructor;
+    errorText: StringConstructor;
+    direction: {
+        type: import("vue").PropType<ListDirection>;
+        default: ListDirection;
+    };
+    loadingText: StringConstructor;
+    finishedText: StringConstructor;
+    immediateCheck: {
+        type: BooleanConstructor;
+        default: true;
+    };
+}>> & {
+    onLoad?: ((...args: any[]) => any) | undefined;
+    "onUpdate:error"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:loading"?: ((...args: any[]) => any) | undefined;
+}, {
+    offset: string | number;
+    disabled: boolean;
+    error: boolean;
+    loading: boolean;
+    direction: ListDirection;
+    finished: boolean;
+    immediateCheck: boolean;
+}>;
+export default _default;

package/lib/list/List.js

@@ -0,0 +1,160 @@
+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,
+  listProps: () => listProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_vue2 = require("vue");
+var import_utils = require("../utils");
+var import_use = require("@vant/use");
+var import_use_expose = require("../composables/use-expose");
+var import_use_tab_status = require("../composables/use-tab-status");
+var import_loading = require("../loading");
+const [name, bem, t] = (0, import_utils.createNamespace)("list");
+const listProps = {
+  error: Boolean,
+  offset: (0, import_utils.makeNumericProp)(300),
+  loading: Boolean,
+  disabled: Boolean,
+  finished: Boolean,
+  errorText: String,
+  direction: (0, import_utils.makeStringProp)("down"),
+  loadingText: String,
+  finishedText: String,
+  immediateCheck: import_utils.truthProp
+};
+var stdin_default = (0, import_vue2.defineComponent)({
+  name,
+  props: listProps,
+  emits: ["load", "update:error", "update:loading"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const loading = (0, import_vue2.ref)(props.loading);
+    const root = (0, import_vue2.ref)();
+    const placeholder = (0, import_vue2.ref)();
+    const tabStatus = (0, import_use_tab_status.useTabStatus)();
+    const scrollParent = (0, import_use.useScrollParent)(root);
+    const check = () => {
+      (0, import_vue2.nextTick)(() => {
+        if (loading.value || props.finished || props.disabled || props.error || (tabStatus == null ? void 0 : tabStatus.value) === false) {
+          return;
+        }
+        const {
+          offset,
+          direction
+        } = props;
+        const scrollParentRect = (0, import_use.useRect)(scrollParent);
+        if (!scrollParentRect.height || (0, import_utils.isHidden)(root)) {
+          return;
+        }
+        let isReachEdge = false;
+        const placeholderRect = (0, import_use.useRect)(placeholder);
+        if (direction === "up") {
+          isReachEdge = scrollParentRect.top - placeholderRect.top <= offset;
+        } else {
+          isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset;
+        }
+        if (isReachEdge) {
+          loading.value = true;
+          emit("update:loading", true);
+          emit("load");
+        }
+      });
+    };
+    const renderFinishedText = () => {
+      if (props.finished) {
+        const text = slots.finished ? slots.finished() : props.finishedText;
+        if (text) {
+          return (0, import_vue.createVNode)("div", {
+            "class": bem("finished-text")
+          }, [text]);
+        }
+      }
+    };
+    const clickErrorText = () => {
+      emit("update:error", false);
+      check();
+    };
+    const renderErrorText = () => {
+      if (props.error) {
+        const text = slots.error ? slots.error() : props.errorText;
+        if (text) {
+          return (0, import_vue.createVNode)("div", {
+            "role": "button",
+            "class": bem("error-text"),
+            "tabindex": 0,
+            "onClick": clickErrorText
+          }, [text]);
+        }
+      }
+    };
+    const renderLoading = () => {
+      if (loading.value && !props.finished && !props.disabled) {
+        return (0, import_vue.createVNode)("div", {
+          "class": bem("loading")
+        }, [slots.loading ? slots.loading() : (0, import_vue.createVNode)(import_loading.Loading, {
+          "class": bem("loading-icon")
+        }, {
+          default: () => [props.loadingText || t("loading")]
+        })]);
+      }
+    };
+    (0, import_vue2.watch)(() => [props.loading, props.finished, props.error], check);
+    if (tabStatus) {
+      (0, import_vue2.watch)(tabStatus, (tabActive) => {
+        if (tabActive) {
+          check();
+        }
+      });
+    }
+    (0, import_vue2.onUpdated)(() => {
+      loading.value = props.loading;
+    });
+    (0, import_vue2.onMounted)(() => {
+      if (props.immediateCheck) {
+        check();
+      }
+    });
+    (0, import_use_expose.useExpose)({
+      check
+    });
+    (0, import_use.useEventListener)("scroll", check, {
+      target: scrollParent,
+      passive: true
+    });
+    return () => {
+      var _a;
+      const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      const Placeholder = (0, import_vue.createVNode)("div", {
+        "ref": placeholder,
+        "class": bem("placeholder")
+      }, null);
+      return (0, import_vue.createVNode)("div", {
+        "ref": root,
+        "role": "feed",
+        "class": bem(),
+        "aria-busy": loading.value
+      }, [props.direction === "down" ? Content : Placeholder, renderLoading(), renderFinishedText(), renderErrorText(), props.direction === "up" ? Content : Placeholder]);
+    };
+  }
+});

package/lib/list/index.css

@@ -0,0 +1 @@
+:root{--van-list-text-color: var(--van-text-color-2);--van-list-text-font-size: var(--van-font-size-md);--van-list-text-line-height: 50px;--van-list-loading-icon-size: 16px}.van-list__loading,.van-list__finished-text,.van-list__error-text{color:var(--van-list-text-color);font-size:var(--van-list-text-font-size);line-height:var(--van-list-text-line-height);text-align:center}.van-list__placeholder{height:0;pointer-events:none}.van-list__loading-icon .van-loading__spinner{width:var(--van-list-loading-icon-size);height:var(--van-list-loading-icon-size)}

package/lib/list/index.d.ts

@@ -0,0 +1,63 @@
+import { ListProps } from './List';
+export declare const List: import("../utils").WithInstall<import("vue").DefineComponent<{
+    error: BooleanConstructor;
+    offset: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    loading: BooleanConstructor;
+    disabled: BooleanConstructor;
+    finished: BooleanConstructor;
+    errorText: StringConstructor;
+    direction: {
+        type: import("vue").PropType<import("./types").ListDirection>;
+        default: import("./types").ListDirection;
+    };
+    loadingText: StringConstructor;
+    finishedText: StringConstructor;
+    immediateCheck: {
+        type: BooleanConstructor;
+        default: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("load" | "update:error" | "update:loading")[], "load" | "update:error" | "update:loading", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    error: BooleanConstructor;
+    offset: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    loading: BooleanConstructor;
+    disabled: BooleanConstructor;
+    finished: BooleanConstructor;
+    errorText: StringConstructor;
+    direction: {
+        type: import("vue").PropType<import("./types").ListDirection>;
+        default: import("./types").ListDirection;
+    };
+    loadingText: StringConstructor;
+    finishedText: StringConstructor;
+    immediateCheck: {
+        type: BooleanConstructor;
+        default: true;
+    };
+}>> & {
+    onLoad?: ((...args: any[]) => any) | undefined;
+    "onUpdate:error"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:loading"?: ((...args: any[]) => any) | undefined;
+}, {
+    offset: string | number;
+    disabled: boolean;
+    error: boolean;
+    loading: boolean;
+    direction: import("./types").ListDirection;
+    finished: boolean;
+    immediateCheck: boolean;
+}>>;
+export default List;
+export { listProps } from './List';
+export type { ListProps };
+export type { ListInstance, ListDirection, ListThemeVars } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanList: typeof List;
+    }
+}

package/lib/list/index.js

@@ -0,0 +1,35 @@
+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(
+  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, {
+  List: () => List,
+  default: () => stdin_default,
+  listProps: () => import_List2.listProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_List = __toESM(require("./List"));
+var import_List2 = require("./List");
+const List = (0, import_utils.withInstall)(import_List.default);
+var stdin_default = List;

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

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

package/lib/list/style/index.js

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

package/lib/list/types.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentPublicInstance } from 'vue';
+import type { ListProps } from './List';
+export type ListDirection = 'up' | 'down';
+export type ListExpose = {
+    check: () => void;
+};
+export type ListInstance = ComponentPublicInstance<ListProps, ListExpose>;
+export type ListThemeVars = {
+    listTextColor?: string;
+    listTextFontSize?: string;
+    listTextLineHeight?: number | string;
+    listLoadingIconSize?: string;
+};

package/lib/list/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);

package/lib/loading/Loading.d.ts

@@ -0,0 +1,39 @@
+import { type ExtractPropTypes } from 'vue';
+export type LoadingType = 'circular' | 'spinner';
+export declare const loadingProps: {
+    size: (NumberConstructor | StringConstructor)[];
+    type: {
+        type: import("vue").PropType<LoadingType>;
+        default: LoadingType;
+    };
+    color: StringConstructor;
+    vertical: BooleanConstructor;
+    textSize: (NumberConstructor | StringConstructor)[];
+    textColor: StringConstructor;
+};
+export type LoadingProps = ExtractPropTypes<typeof loadingProps>;
+declare const _default: import("vue").DefineComponent<{
+    size: (NumberConstructor | StringConstructor)[];
+    type: {
+        type: import("vue").PropType<LoadingType>;
+        default: LoadingType;
+    };
+    color: StringConstructor;
+    vertical: BooleanConstructor;
+    textSize: (NumberConstructor | StringConstructor)[];
+    textColor: StringConstructor;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    size: (NumberConstructor | StringConstructor)[];
+    type: {
+        type: import("vue").PropType<LoadingType>;
+        default: LoadingType;
+    };
+    color: StringConstructor;
+    vertical: BooleanConstructor;
+    textSize: (NumberConstructor | StringConstructor)[];
+    textColor: StringConstructor;
+}>>, {
+    type: LoadingType;
+    vertical: boolean;
+}>;
+export default _default;