vant 3.3.6 → 3.4.2

package/es/lazyload/vue-lazyload/listener.js

@@ -1,20 +1,19 @@
-import { useRect } from '@vant/use';
-import { loadImageAsync } from './util';
-import { noop } from '../../utils';
-export default class ReactiveListener {
-  constructor(_ref) {
-    var {
-      el,
-      src,
-      error,
-      loading,
-      bindType,
-      $parent,
-      options,
-      cors,
-      elRenderer,
-      imageCache
-    } = _ref;
+import { useRect } from "@vant/use";
+import { loadImageAsync } from "./util";
+import { noop } from "../../utils";
+class ReactiveListener {
+  constructor({
+    el,
+    src,
+    error,
+    loading,
+    bindType,
+    $parent,
+    options,
+    cors,
+    elRenderer,
+    imageCache
+  }) {
     this.el = el;
     this.src = src;
     this.error = error;
@@ -34,21 +33,14 @@ export default class ReactiveListener {
     };
     this.filter();
     this.initState();
-    this.render('loading', false);
+    this.render("loading", false);
   }
-  /*
-   * init listener state
-   * @return
-   */
-
-
   initState() {
-    if ('dataset' in this.el) {
+    if ("dataset" in this.el) {
       this.el.dataset.src = this.src;
     } else {
-      this.el.setAttribute('data-src', this.src);
+      this.el.setAttribute("data-src", this.src);
     }
-
     this.state = {
       loading: false,
       error: false,
@@ -56,179 +48,105 @@ export default class ReactiveListener {
       rendered: false
     };
   }
-  /*
-   * record performance
-   * @return
-   */
-
-
   record(event) {
     this.performanceData[event] = Date.now();
   }
-  /*
-   * update image listener data
-   * @param  {String} image uri
-   * @param  {String} loading image uri
-   * @param  {String} error image uri
-   * @return
-   */
-
-
-  update(_ref2) {
-    var {
-      src,
-      loading,
-      error
-    } = _ref2;
-    var oldSrc = this.src;
+  update({ src, loading, error }) {
+    const oldSrc = this.src;
     this.src = src;
     this.loading = loading;
     this.error = error;
     this.filter();
-
     if (oldSrc !== this.src) {
       this.attempt = 0;
       this.initState();
     }
   }
-  /*
-   *  check el is in view
-   * @return {Boolean} el is in view
-   */
-
-
   checkInView() {
-    var rect = useRect(this.el);
+    const rect = useRect(this.el);
     return rect.top < window.innerHeight * this.options.preLoad && rect.bottom > this.options.preLoadTop && rect.left < window.innerWidth * this.options.preLoad && rect.right > 0;
   }
-  /*
-   * listener filter
-   */
-
-
   filter() {
-    Object.keys(this.options.filter).forEach(key => {
+    Object.keys(this.options.filter).forEach((key) => {
       this.options.filter[key](this, this.options);
     });
   }
-  /*
-   * render loading first
-   * @params cb:Function
-   * @return
-   */
-
-
   renderLoading(cb) {
     this.state.loading = true;
     loadImageAsync({
       src: this.loading,
       cors: this.cors
     }, () => {
-      this.render('loading', false);
+      this.render("loading", false);
       this.state.loading = false;
       cb();
     }, () => {
-      // handler `loading image` load failed
       cb();
       this.state.loading = false;
-      if (process.env.NODE_ENV !== 'production' && !this.options.silent) console.warn("[@vant/lazyload] load failed with loading image(" + this.loading + ")");
+      if (process.env.NODE_ENV !== "production" && !this.options.silent)
+        console.warn(`[@vant/lazyload] load failed with loading image(${this.loading})`);
     });
   }
-  /*
-   * try load image and  render it
-   * @return
-   */
-
-
-  load(onFinish) {
-    if (onFinish === void 0) {
-      onFinish = noop;
-    }
-
+  load(onFinish = noop) {
     if (this.attempt > this.options.attempt - 1 && this.state.error) {
-      if (process.env.NODE_ENV !== 'production' && !this.options.silent) {
-        console.log("[@vant/lazyload] " + this.src + " tried too more than " + this.options.attempt + " times");
+      if (process.env.NODE_ENV !== "production" && !this.options.silent) {
+        console.log(`[@vant/lazyload] ${this.src} tried too more than ${this.options.attempt} times`);
       }
-
       onFinish();
       return;
     }
-
-    if (this.state.rendered && this.state.loaded) return;
-
+    if (this.state.rendered && this.state.loaded)
+      return;
     if (this.imageCache.has(this.src)) {
       this.state.loaded = true;
-      this.render('loaded', true);
+      this.render("loaded", true);
       this.state.rendered = true;
       return onFinish();
     }
-
     this.renderLoading(() => {
-      var _this$options$adapter, _this$options$adapter2;
-
+      var _a, _b;
       this.attempt++;
-      (_this$options$adapter = (_this$options$adapter2 = this.options.adapter).beforeLoad) == null ? void 0 : _this$options$adapter.call(_this$options$adapter2, this, this.options);
-      this.record('loadStart');
+      (_b = (_a = this.options.adapter).beforeLoad) == null ? void 0 : _b.call(_a, this, this.options);
+      this.record("loadStart");
       loadImageAsync({
         src: this.src,
         cors: this.cors
-      }, data => {
+      }, (data) => {
         this.naturalHeight = data.naturalHeight;
         this.naturalWidth = data.naturalWidth;
         this.state.loaded = true;
         this.state.error = false;
-        this.record('loadEnd');
-        this.render('loaded', false);
+        this.record("loadEnd");
+        this.render("loaded", false);
         this.state.rendered = true;
         this.imageCache.add(this.src);
         onFinish();
-      }, err => {
+      }, (err) => {
         !this.options.silent && console.error(err);
         this.state.error = true;
         this.state.loaded = false;
-        this.render('error', false);
+        this.render("error", false);
       });
     });
   }
-  /*
-   * render image
-   * @param  {String} state to render // ['loading', 'src', 'error']
-   * @param  {String} is form cache
-   * @return
-   */
-
-
   render(state, cache) {
     this.elRenderer(this, state, cache);
   }
-  /*
-   * output performance data
-   * @return {Object} performance data
-   */
-
-
   performance() {
-    var state = 'loading';
-    var time = 0;
-
+    let state = "loading";
+    let time = 0;
     if (this.state.loaded) {
-      state = 'loaded';
-      time = (this.performanceData.loadEnd - this.performanceData.loadStart) / 1000;
+      state = "loaded";
+      time = (this.performanceData.loadEnd - this.performanceData.loadStart) / 1e3;
     }
-
-    if (this.state.error) state = 'error';
+    if (this.state.error)
+      state = "error";
     return {
       src: this.src,
       state,
       time
     };
   }
-  /*
-   * $destroy
-   * @return
-   */
-
-
   $destroy() {
     this.el = null;
     this.src = null;
@@ -237,5 +155,7 @@ export default class ReactiveListener {
     this.bindType = null;
     this.attempt = 0;
   }
-
-}
+}
+export {
+  ReactiveListener as default
+};

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

@@ -1,27 +1,29 @@
-import { inBrowser } from '@vant/use';
-export var hasIntersectionObserver = inBrowser && 'IntersectionObserver' in window && 'IntersectionObserverEntry' in window && 'intersectionRatio' in window.IntersectionObserverEntry.prototype;
-export var modeType = {
-  event: 'event',
-  observer: 'observer'
+import { inBrowser } from "@vant/use";
+const hasIntersectionObserver = inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype;
+const modeType = {
+  event: "event",
+  observer: "observer"
 };
-export function remove(arr, item) {
-  if (!arr.length) return;
-  var index = arr.indexOf(item);
-  if (index > -1) return arr.splice(index, 1);
+function remove(arr, item) {
+  if (!arr.length)
+    return;
+  const index = arr.indexOf(item);
+  if (index > -1)
+    return arr.splice(index, 1);
 }
-export function getBestSelectionFromSrcset(el, scale) {
-  if (el.tagName !== 'IMG' || !el.getAttribute('data-srcset')) return;
-  var options = el.getAttribute('data-srcset');
-  var container = el.parentNode;
-  var containerWidth = container.offsetWidth * scale;
-  var spaceIndex;
-  var tmpSrc;
-  var tmpWidth;
-  options = options.trim().split(',');
-  var result = options.map(item => {
+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(' ');
-
+    spaceIndex = item.lastIndexOf(" ");
     if (spaceIndex === -1) {
       tmpSrc = item;
       tmpWidth = 999998;
@@ -29,38 +31,31 @@ export function getBestSelectionFromSrcset(el, scale) {
       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) {
+      if (b[1].indexOf(".webp", b[1].length - 5) !== -1) {
         return 1;
       }
-
-      if (a[1].indexOf('.webp', a[1].length - 5) !== -1) {
+      if (a[1].indexOf(".webp", a[1].length - 5) !== -1) {
         return -1;
       }
     }
-
     return 0;
   });
-  var bestSelectedSrc = '';
-  var tmpOption;
-
-  for (var i = 0; i < result.length; i++) {
+  let bestSelectedSrc = "";
+  let tmpOption;
+  for (let i = 0; i < result.length; i++) {
     tmpOption = result[i];
     bestSelectedSrc = tmpOption[1];
-    var next = result[i + 1];
-
+    const next = result[i + 1];
     if (next && next[0] < containerWidth) {
       bestSelectedSrc = tmpOption[1];
       break;
@@ -69,52 +64,36 @@ export function getBestSelectionFromSrcset(el, scale) {
       break;
     }
   }
-
   return bestSelectedSrc;
 }
-export var getDPR = function (scale) {
-  if (scale === void 0) {
-    scale = 1;
-  }
-
-  return inBrowser ? window.devicePixelRatio || scale : scale;
-};
-export function supportWebp() {
-  if (!inBrowser) return false;
-  var support = true;
-
+const getDPR = (scale = 1) => inBrowser ? window.devicePixelRatio || scale : scale;
+function supportWebp() {
+  if (!inBrowser)
+    return false;
+  let support = true;
   try {
-    var elem = document.createElement('canvas');
-
-    if (elem.getContext && elem.getContext('2d')) {
-      support = elem.toDataURL('image/webp').indexOf('data:image/webp') === 0;
+    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;
 }
-export function throttle(action, delay) {
-  var timeout = null;
-  var lastRun = 0;
-  return function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
+function throttle(action, delay) {
+  let timeout = null;
+  let lastRun = 0;
+  return function(...args) {
     if (timeout) {
       return;
     }
-
-    var elapsed = Date.now() - lastRun;
-
-    var runCallback = () => {
+    const elapsed = Date.now() - lastRun;
+    const runCallback = () => {
       lastRun = Date.now();
       timeout = false;
       action.apply(this, args);
     };
-
     if (elapsed >= delay) {
       runCallback();
     } else {
@@ -122,62 +101,63 @@ export function throttle(action, delay) {
     }
   };
 }
-export function on(el, type, func) {
+function on(el, type, func) {
   el.addEventListener(type, func, {
     capture: false,
     passive: true
   });
 }
-export function off(el, type, func) {
+function off(el, type, func) {
   el.removeEventListener(type, func, false);
 }
-export var loadImageAsync = (item, resolve, reject) => {
-  var image = new Image();
-
+const loadImageAsync = (item, resolve, reject) => {
+  const image = new Image();
   if (!item || !item.src) {
-    return reject(new Error('image src is required'));
+    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);
+  image.onerror = (e) => reject(e);
 };
-export class ImageCache {
-  constructor(_ref) {
-    var {
-      max
-    } = _ref;
+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;
+    if (this.has(key))
+      return;
     this.caches.push(key);
-
     if (this.caches.length > this.options.max) {
       this.free();
     }
   }
-
   free() {
     this.caches.shift();
   }
-
-}
+}
+export {
+  ImageCache,
+  getBestSelectionFromSrcset,
+  getDPR,
+  hasIntersectionObserver,
+  loadImageAsync,
+  modeType,
+  off,
+  on,
+  remove,
+  supportWebp,
+  throttle
+};

package/es/list/List.d.ts

@@ -1,4 +1,4 @@
-import { ExtractPropTypes } from 'vue';
+import { type ExtractPropTypes } from 'vue';
 import type { ListDirection } from './types';
 declare const listProps: {
     error: BooleanConstructor;
@@ -40,28 +40,26 @@ declare const _default: import("vue").DefineComponent<{
         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/runtime-core").ComponentCustomProps, Readonly<{
-    error?: unknown;
-    offset?: unknown;
-    loading?: unknown;
-    finished?: unknown;
-    errorText?: unknown;
-    direction?: unknown;
-    loadingText?: unknown;
-    finishedText?: unknown;
-    immediateCheck?: unknown;
-} & {
-    offset: string | number;
-    error: boolean;
-    loading: boolean;
-    direction: ListDirection;
-    finished: boolean;
-    immediateCheck: boolean;
-} & {
-    loadingText?: string | undefined;
-    errorText?: string | undefined;
-    finishedText?: string | undefined;
-}> & {
+}, () => 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;
+    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;