persagy-vant 0.0.29 → 0.0.31

package/es/uploader/index.d.ts

@@ -0,0 +1,154 @@
+import { UploaderProps } from './Uploader';
+export declare const Uploader: import("../utils").WithInstall<import("vue").DefineComponent<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: import("vue").PropType<import("..").ImageFit>;
+        default: import("..").ImageFit;
+    };
+    resultType: {
+        type: import("vue").PropType<import("./types").UploaderResultType>;
+        default: import("./types").UploaderResultType;
+    };
+    uploadIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
+    beforeDelete: import("vue").PropType<import("../utils").Interceptor>;
+    previewSize: import("vue").PropType<import("../utils").Numeric | [import("../utils").Numeric, import("../utils").Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: import("vue").PropType<Partial<import("..").ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: import("vue").PropType<import("./types").UploaderMaxSize>;
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "delete" | "oversize" | "click-upload" | "close-preview" | "click-preview")[], "update:modelValue" | "delete" | "oversize" | "click-upload" | "close-preview" | "click-preview", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: import("vue").PropType<import("..").ImageFit>;
+        default: import("..").ImageFit;
+    };
+    resultType: {
+        type: import("vue").PropType<import("./types").UploaderResultType>;
+        default: import("./types").UploaderResultType;
+    };
+    uploadIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
+    beforeDelete: import("vue").PropType<import("../utils").Interceptor>;
+    previewSize: import("vue").PropType<import("../utils").Numeric | [import("../utils").Numeric, import("../utils").Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: import("vue").PropType<Partial<import("..").ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: import("vue").PropType<import("./types").UploaderMaxSize>;
+        default: number;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onOversize?: ((...args: any[]) => any) | undefined;
+    "onClick-upload"?: ((...args: any[]) => any) | undefined;
+    "onClose-preview"?: ((...args: any[]) => any) | undefined;
+    "onClick-preview"?: ((...args: any[]) => any) | undefined;
+}, {
+    name: string | number;
+    accept: string;
+    disabled: boolean;
+    modelValue: import("./types").UploaderFileListItem[];
+    readonly: boolean;
+    multiple: boolean;
+    lazyLoad: boolean;
+    maxCount: string | number;
+    imageFit: import("..").ImageFit;
+    resultType: import("./types").UploaderResultType;
+    uploadIcon: string;
+    deletable: boolean;
+    showUpload: boolean;
+    previewImage: boolean;
+    previewFullImage: boolean;
+    maxSize: import("./types").UploaderMaxSize;
+}>>;
+export default Uploader;
+export type { UploaderProps };
+export type { UploaderInstance, UploaderResultType, UploaderFileListItem, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanUploader: typeof Uploader;
+    }
+}

package/es/uploader/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _Uploader from "./Uploader.mjs";
+const Uploader = withInstall(_Uploader);
+var stdin_default = Uploader;
+export {
+  Uploader,
+  stdin_default as default
+};

package/es/uploader/style/index.mjs

@@ -0,0 +1,11 @@
+import "../../style/base.css";
+import "../../badge/index.css";
+import "../../icon/index.css";
+import "../../image/index.css";
+import "../../loading/index.css";
+import "../../overlay/index.css";
+import "../../popup/index.css";
+import "../../swipe/index.css";
+import "../../swipe-item/index.css";
+import "../../image-preview/index.css";
+import "../index.css";

package/es/uploader/style/less.mjs

@@ -0,0 +1,11 @@
+import "../../style/base.less";
+import "../../badge/index.less";
+import "../../icon/index.less";
+import "../../image/index.less";
+import "../../loading/index.less";
+import "../../overlay/index.less";
+import "../../popup/index.less";
+import "../../swipe/index.less";
+import "../../swipe-item/index.less";
+import "../../image-preview/index.less";
+import "../index.less";

package/es/uploader/types.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentPublicInstance } from 'vue';
+import type { ImageFit } from '../image';
+import type { Numeric, Interceptor } from '../utils';
+import type { UploaderProps } from './Uploader';
+export declare type UploaderResultType = 'dataUrl' | 'text' | 'file';
+export declare type UploaderFileListItem = {
+    url?: string;
+    file?: File;
+    content?: string;
+    isImage?: boolean;
+    status?: '' | 'uploading' | 'done' | 'failed';
+    message?: string;
+    imageFit?: ImageFit;
+    deletable?: boolean;
+    previewSize?: Numeric;
+    beforeDelete?: Interceptor;
+};
+export declare type UploaderMaxSize = Numeric | ((file: File) => boolean);
+export declare type UploaderBeforeRead = (file: File | File[], detail: {
+    name: Numeric;
+    index: number;
+}) => boolean | undefined | Promise<File | File[] | undefined>;
+export declare type UploaderAfterRead = (items: UploaderFileListItem | UploaderFileListItem[], detail: {
+    name: Numeric;
+    index: number;
+}) => void;
+export declare type UploaderExpose = {
+    chooseFile: () => void;
+    closeImagePreview: () => void;
+};
+export declare type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;

package/es/uploader/utils.d.ts

@@ -0,0 +1,11 @@
+import type { UploaderMaxSize, UploaderResultType, UploaderFileListItem } from './types';
+declare const name: string, bem: (el?: import("../utils").Mods | undefined, mods?: import("../utils").Mods | undefined) => import("../utils").Mods, t: (path: string, ...args: unknown[]) => any;
+export { name, bem, t };
+export declare function readFileContent(file: File, resultType: UploaderResultType): Promise<string | void>;
+export declare function isOversize(items: UploaderFileListItem | UploaderFileListItem[], maxSize: UploaderMaxSize): boolean;
+export declare function filterFiles(items: UploaderFileListItem[], maxSize: UploaderMaxSize): {
+    valid: UploaderFileListItem[];
+    invalid: UploaderFileListItem[];
+};
+export declare const isImageUrl: (url: string) => boolean;
+export declare function isImageFile(item: UploaderFileListItem): boolean;

package/es/uploader/utils.mjs

@@ -0,0 +1,69 @@
+import { toArray, createNamespace, isFunction } from "../utils/index.mjs";
+const [name, bem, t] = createNamespace("uploader");
+function readFileContent(file, resultType) {
+  return new Promise((resolve) => {
+    if (resultType === "file") {
+      resolve();
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      resolve(event.target.result);
+    };
+    if (resultType === "dataUrl") {
+      reader.readAsDataURL(file);
+    } else if (resultType === "text") {
+      reader.readAsText(file);
+    }
+  });
+}
+function isOversize(items, maxSize) {
+  return toArray(items).some((item) => {
+    if (item.file) {
+      if (isFunction(maxSize)) {
+        return maxSize(item.file);
+      }
+      return item.file.size > maxSize;
+    }
+    return false;
+  });
+}
+function filterFiles(items, maxSize) {
+  const valid = [];
+  const invalid = [];
+  items.forEach((item) => {
+    if (isOversize(item, maxSize)) {
+      invalid.push(item);
+    } else {
+      valid.push(item);
+    }
+  });
+  return { valid, invalid };
+}
+const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i;
+const isImageUrl = (url) => IMAGE_REGEXP.test(url);
+function isImageFile(item) {
+  if (item.isImage) {
+    return true;
+  }
+  if (item.file && item.file.type) {
+    return item.file.type.indexOf("image") === 0;
+  }
+  if (item.url) {
+    return isImageUrl(item.url);
+  }
+  if (typeof item.content === "string") {
+    return item.content.indexOf("data:image") === 0;
+  }
+  return false;
+}
+export {
+  bem,
+  filterFiles,
+  isImageFile,
+  isImageUrl,
+  isOversize,
+  name,
+  readFileContent,
+  t
+};

package/es/utils/basic.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentPublicInstance } from 'vue';
+export declare function noop(): void;
+export declare const extend: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const inBrowser: boolean;
+export declare type Numeric = number | string;
+export declare type ComponentInstance = ComponentPublicInstance<{}, any>;
+export declare function get(object: any, path: string): any;
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>, ignoreUndefined?: boolean): Writeable<Pick<T, U>>;
+export declare const toArray: <T>(item: T | T[]) => T[];

package/es/utils/basic.mjs

@@ -0,0 +1,31 @@
+import { isObject } from "./validate.mjs";
+function noop() {
+}
+const extend = Object.assign;
+const inBrowser = typeof window !== "undefined";
+function get(object, path) {
+  const keys = path.split(".");
+  let result = object;
+  keys.forEach((key) => {
+    var _a;
+    result = isObject(result) ? (_a = result[key]) != null ? _a : "" : "";
+  });
+  return result;
+}
+function pick(obj, keys, ignoreUndefined) {
+  return keys.reduce((ret, key) => {
+    if (!ignoreUndefined || obj[key] !== void 0) {
+      ret[key] = obj[key];
+    }
+    return ret;
+  }, {});
+}
+const toArray = (item) => Array.isArray(item) ? item : [item];
+export {
+  extend,
+  get,
+  inBrowser,
+  noop,
+  pick,
+  toArray
+};

package/es/utils/constant.d.ts

@@ -0,0 +1,11 @@
+import type { InjectionKey } from 'vue';
+import type { FormProvide } from '../form/types';
+export declare const BORDER = "van-hairline";
+export declare const BORDER_TOP: string;
+export declare const BORDER_LEFT: string;
+export declare const BORDER_BOTTOM: string;
+export declare const BORDER_SURROUND: string;
+export declare const BORDER_TOP_BOTTOM: string;
+export declare const BORDER_UNSET_TOP_BOTTOM: string;
+export declare const HAPTICS_FEEDBACK = "van-haptics-feedback";
+export declare const FORM_KEY: InjectionKey<FormProvide>;

package/es/utils/constant.mjs

@@ -0,0 +1,20 @@
+const BORDER = "van-hairline";
+const BORDER_TOP = `${BORDER}--top`;
+const BORDER_LEFT = `${BORDER}--left`;
+const BORDER_BOTTOM = `${BORDER}--bottom`;
+const BORDER_SURROUND = `${BORDER}--surround`;
+const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
+const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
+const HAPTICS_FEEDBACK = "van-haptics-feedback";
+const FORM_KEY = Symbol("van-form");
+export {
+  BORDER,
+  BORDER_BOTTOM,
+  BORDER_LEFT,
+  BORDER_SURROUND,
+  BORDER_TOP,
+  BORDER_TOP_BOTTOM,
+  BORDER_UNSET_TOP_BOTTOM,
+  FORM_KEY,
+  HAPTICS_FEEDBACK
+};

package/es/utils/create.d.ts

@@ -0,0 +1,17 @@
+export declare function createTranslate(name: string): (path: string, ...args: unknown[]) => any;
+export declare type Translate = ReturnType<typeof createTranslate>;
+export declare type Mod = string | {
+    [key: string]: any;
+};
+export declare type Mods = Mod | Mod[];
+/**
+ * bem helper
+ * b() // 'button'
+ * b('text') // 'button__text'
+ * b({ disabled }) // 'button button--disabled'
+ * b('text', { disabled }) // 'button__text button__text--disabled'
+ * b(['disabled', 'primary']) // 'button button--disabled button--primary'
+ */
+export declare function createBEM(name: string): (el?: Mods, mods?: Mods) => Mods;
+export declare type BEM = ReturnType<typeof createBEM>;
+export declare function createNamespace(name: string): readonly [string, (el?: Mods | undefined, mods?: Mods | undefined) => Mods, (path: string, ...args: unknown[]) => any];

package/es/utils/create.mjs

@@ -0,0 +1,53 @@
+import { get } from "./basic.mjs";
+import { camelize } from "./format.mjs";
+import { isFunction } from "./validate.mjs";
+import locale from "../locale/index.mjs";
+function createTranslate(name) {
+  const prefix = camelize(name) + ".";
+  return (path, ...args) => {
+    const messages = locale.messages();
+    const message = get(messages, prefix + path) || get(messages, path);
+    return isFunction(message) ? message(...args) : message;
+  };
+}
+function genBem(name, mods) {
+  if (!mods) {
+    return "";
+  }
+  if (typeof mods === "string") {
+    return ` ${name}--${mods}`;
+  }
+  if (Array.isArray(mods)) {
+    return mods.reduce(
+      (ret, item) => ret + genBem(name, item),
+      ""
+    );
+  }
+  return Object.keys(mods).reduce(
+    (ret, key) => ret + (mods[key] ? genBem(name, key) : ""),
+    ""
+  );
+}
+function createBEM(name) {
+  return (el, mods) => {
+    if (el && typeof el !== "string") {
+      mods = el;
+      el = "";
+    }
+    el = el ? `${name}__${el}` : name;
+    return `${el}${genBem(el, mods)}`;
+  };
+}
+function createNamespace(name) {
+  const prefixedName = `van-${name}`;
+  return [
+    prefixedName,
+    createBEM(prefixedName),
+    createTranslate(prefixedName)
+  ];
+}
+export {
+  createBEM,
+  createNamespace,
+  createTranslate
+};

package/es/utils/deep-assign.d.ts

@@ -0,0 +1,3 @@
+declare type ObjectIndex = Record<string, unknown>;
+export declare function deepAssign(to: ObjectIndex, from: ObjectIndex): ObjectIndex;
+export {};

package/es/utils/deep-assign.mjs

@@ -0,0 +1,22 @@
+import { isDef, isObject } from "./validate.mjs";
+const { hasOwnProperty } = Object.prototype;
+function assignKey(to, from, key) {
+  const val = from[key];
+  if (!isDef(val)) {
+    return;
+  }
+  if (!hasOwnProperty.call(to, key) || !isObject(val)) {
+    to[key] = val;
+  } else {
+    to[key] = deepAssign(Object(to[key]), val);
+  }
+}
+function deepAssign(to, from) {
+  Object.keys(from).forEach((key) => {
+    assignKey(to, from, key);
+  });
+  return to;
+}
+export {
+  deepAssign
+};

package/es/utils/deep-clone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T extends Record<string, any> | null | undefined>(obj: T): T;

package/es/utils/deep-clone.mjs

@@ -0,0 +1,20 @@
+import { isDef, isObject } from "./validate.mjs";
+function deepClone(obj) {
+  if (!isDef(obj)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (isObject(obj)) {
+    const to = {};
+    Object.keys(obj).forEach((key) => {
+      to[key] = deepClone(obj[key]);
+    });
+    return to;
+  }
+  return obj;
+}
+export {
+  deepClone
+};

package/es/utils/dom.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+export declare type ScrollElement = Element | Window;
+export declare function getScrollTop(el: ScrollElement): number;
+export declare function setScrollTop(el: ScrollElement, value: number): void;
+export declare function getRootScrollTop(): number;
+export declare function setRootScrollTop(value: number): void;
+export declare function getElementTop(el: ScrollElement, scroller?: ScrollElement): number;
+export declare function resetScroll(): void;
+export declare const stopPropagation: (event: Event) => void;
+export declare function preventDefault(event: Event, isStopPropagation?: boolean): void;
+export declare function isHidden(elementRef: HTMLElement | Ref<HTMLElement | undefined>): boolean;
+export declare const windowWidth: Ref<number>, windowHeight: Ref<number>;

package/es/utils/dom.mjs

@@ -0,0 +1,67 @@
+import { useRect, useWindowSize } from "@vant/use";
+import { unref } from "vue";
+import { isIOS as checkIsIOS } from "./validate.mjs";
+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 useRect(el).top + scrollTop;
+}
+const isIOS = checkIsIOS();
+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 = 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 } = useWindowSize();
+export {
+  getElementTop,
+  getRootScrollTop,
+  getScrollTop,
+  isHidden,
+  preventDefault,
+  resetScroll,
+  setRootScrollTop,
+  setScrollTop,
+  stopPropagation,
+  windowHeight,
+  windowWidth
+};

package/es/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;