zartui 3.0.1 → 3.0.3

package/es/uploader/index.d.ts

@@ -0,0 +1,155 @@
+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: () => import("./types").UploaderFileListItem[];
+    };
+    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" | "clickUpload" | "closePreview" | "clickPreview")[], "update:modelValue" | "delete" | "oversize" | "clickUpload" | "closePreview" | "clickPreview", 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: () => import("./types").UploaderFileListItem[];
+    };
+    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;
+    onClickUpload?: ((...args: any[]) => any) | undefined;
+    onClosePreview?: ((...args: any[]) => any) | undefined;
+    onClickPreview?: ((...args: any[]) => any) | undefined;
+}, {
+    name: string | number;
+    accept: string;
+    disabled: boolean;
+    modelValue: import("./types").UploaderFileListItem[];
+    readonly: boolean;
+    multiple: boolean;
+    lazyLoad: boolean;
+    resultType: import("./types").UploaderResultType;
+    maxCount: string | number;
+    imageFit: import("..").ImageFit;
+    uploadIcon: string;
+    deletable: boolean;
+    showUpload: boolean;
+    previewImage: boolean;
+    previewFullImage: boolean;
+    maxSize: import("./types").UploaderMaxSize;
+}>>;
+export default Uploader;
+export { uploaderProps } from './Uploader';
+export type { UploaderProps };
+export type { UploaderInstance, UploaderResultType, UploaderFileListItem, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        ZtUploader: typeof Uploader;
+    }
+}

package/es/uploader/index.mjs

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

package/es/uploader/style/index.d.ts

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

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 "../../overlay/index.css";
+import "../../popup/index.css";
+import "../../loading/index.css";
+import "../../swipe/index.css";
+import "../../swipe-item/index.css";
+import "../../image-preview/index.css";
+import "../index.css";

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.mjs

@@ -1,3 +1,4 @@
+import { isObject } from "./validate.mjs";
 function noop() {
 }
 const extend = Object.assign;
@@ -7,7 +8,7 @@ function get(object, path) {
   let result = object;
   keys.forEach((key) => {
     var _a;
-    result = (_a = result[key]) != null ? _a : "";
+    result = isObject(result) ? (_a = result[key]) != null ? _a : "" : "";
   });
   return result;
 }

package/es/utils/constant.d.ts

@@ -1,3 +1,5 @@
+import type { InjectionKey } from 'vue';
+import type { FormProvide } from '../form/types';
 export declare const BORDER = "zt-hairline";
 export declare const BORDER_TOP: string;
 export declare const BORDER_LEFT: string;
@@ -6,3 +8,5 @@ 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 = "zt-haptics-feedback";
+export declare const ELLIPSIS = "zt-ellipsis";
+export declare const FORM_KEY: InjectionKey<FormProvide>;

package/es/utils/constant.mjs

@@ -6,6 +6,8 @@ const BORDER_SURROUND = `${BORDER}--surround`;
 const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
 const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
 const HAPTICS_FEEDBACK = "zt-haptics-feedback";
+const ELLIPSIS = "zt-ellipsis";
+const FORM_KEY = Symbol("zt-form");
 export {
   BORDER,
   BORDER_BOTTOM,
@@ -14,5 +16,7 @@ export {
   BORDER_TOP,
   BORDER_TOP_BOTTOM,
   BORDER_UNSET_TOP_BOTTOM,
+  ELLIPSIS,
+  FORM_KEY,
   HAPTICS_FEEDBACK
 };

package/es/utils/create.mjs

@@ -18,7 +18,10 @@ function genBem(name, mods) {
     return ` ${name}--${mods}`;
   }
   if (Array.isArray(mods)) {
-    return mods.reduce((ret, item) => ret + genBem(name, item), "");
+    return mods.reduce(
+      (ret, item) => ret + genBem(name, item),
+      ""
+    );
   }
   return Object.keys(mods).reduce(
     (ret, key) => ret + (mods[key] ? genBem(name, key) : ""),

package/es/utils/date.d.ts

@@ -0,0 +1,29 @@
+export declare const weekList: string[];
+export declare const FORMAT: {
+    FORMAT_HM: string;
+    FORMAT_MDHM: string;
+    FORMAT_MD_CN: string;
+    FORMAT_MD: string;
+    FORMAT_YMD: string;
+    FORMAT_YMD_SLASH: string;
+    FORMAT_YM: string;
+    FORMAT_YMDHM: string;
+    FORMAT_YMDHMS: string;
+    FORMAT_YMDHMSMS: string;
+    FORMAT_YM_CN: string;
+    FORMAT_YMD_CN: string;
+    FORMAT_YMDH_CN: string;
+    FORMAT_MDH_CN: string;
+    FORMAT_YMDHM_CN: string;
+    FORMAT_YMDHMS_CN: string;
+};
+/**
+ * 创建 Date对象
+ * @param dateObj 可传入：
+ * 1. number格式的timestamp；
+ * 2. string格式的日期字符串
+ * 3. Date对象将原封不动的返回
+ * @returns {null|Date|*}
+ */
+export declare function createDate(dateObj: string | number | Date): Date | null;
+export declare function formatDate(dateObj: number | string | Date, formatType?: string): string | null;

package/es/utils/date.mjs

@@ -0,0 +1,96 @@
+import { isDate, isDef } from "./validate.mjs";
+const weekList = [
+  "\u5468\u65E5",
+  "\u5468\u4E00",
+  "\u5468\u4E8C",
+  "\u5468\u4E09",
+  "\u5468\u56DB",
+  "\u5468\u4E94",
+  "\u5468\u516D"
+];
+const FORMAT = {
+  FORMAT_HM: "HH:mm",
+  FORMAT_MDHM: "MM-dd HH:mm",
+  FORMAT_MD_CN: "MM\u6708dd\u65E5",
+  FORMAT_MD: "MM-dd",
+  FORMAT_YMD: "yyyy-MM-dd",
+  FORMAT_YMD_SLASH: "yyyy/MM/dd",
+  FORMAT_YM: "yyyy-MM",
+  FORMAT_YMDHM: "yyyy-MM-dd HH:mm",
+  FORMAT_YMDHMS: "yyyy-MM-dd HH:mm:ss",
+  FORMAT_YMDHMSMS: "yyyy-MM-dd HH:mm:ss msms",
+  FORMAT_YM_CN: "yyyy\u5E74MM\u6708",
+  FORMAT_YMD_CN: "yyyy\u5E74MM\u6708dd\u65E5",
+  FORMAT_YMDH_CN: "yyyy\u5E74MM\u6708dd\u65E5 HH\u65F6",
+  FORMAT_MDH_CN: "MM\u6708dd\u65E5 HH\u65F6",
+  FORMAT_YMDHM_CN: "yyyy\u5E74MM\u6708dd\u65E5 HH\u65F6mm\u5206",
+  FORMAT_YMDHMS_CN: "yyyy\u5E74MM\u6708dd\u65E5  HH\u65F6mm\u5206ss\u79D2"
+};
+const __formatNumber__ = function(number) {
+  if (number < 10) {
+    return "0" + number;
+  }
+  return number + "";
+};
+function createDate(dateObj) {
+  if (!isDef(dateObj)) {
+    return null;
+  }
+  if (typeof dateObj === "number") {
+    return new Date(dateObj);
+  }
+  if (typeof dateObj === "string") {
+    dateObj = dateObj.replace(/-/g, "/");
+    if (dateObj.length === 7) {
+      dateObj += "/01";
+    }
+    return new Date(dateObj);
+  }
+  if (isDate(dateObj)) {
+    return dateObj;
+  }
+  return null;
+}
+function formatDate(dateObj, formatType = FORMAT.FORMAT_YMDHMS) {
+  const date = createDate(dateObj);
+  if (date) {
+    date.getFullYear();
+    let formatResult = formatType.replace(
+      "yyyy",
+      __formatNumber__(date.getFullYear())
+    );
+    formatResult = formatResult.replace(
+      "yy",
+      String(date.getFullYear()).substring(2)
+    );
+    formatResult = formatResult.replace(
+      "MM",
+      __formatNumber__(date.getMonth() + 1)
+    );
+    formatResult = formatResult.replace("dd", __formatNumber__(date.getDate()));
+    formatResult = formatResult.replace(
+      "HH",
+      __formatNumber__(date.getHours())
+    );
+    formatResult = formatResult.replace(
+      "mm",
+      __formatNumber__(date.getMinutes())
+    );
+    formatResult = formatResult.replace(
+      "ss",
+      __formatNumber__(date.getSeconds())
+    );
+    formatResult = formatResult.replace(
+      "msms",
+      __formatNumber__(date.getMilliseconds())
+    );
+    return formatResult;
+  }
+  return null;
+}
+export {
+  FORMAT,
+  createDate,
+  formatDate,
+  weekList
+};

package/es/utils/format.d.ts

@@ -1,5 +1,5 @@
 import type { CSSProperties } from 'vue';
-import { type Numeric } from './basic';
+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;

package/es/utils/parse.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 解析整数
+ * @param obj， 输入字符串
+ * @param defaultValue，默认值
+ */
+export declare const parseNumber: (obj: string, defaultValue?: number) => number;
+/**
+ * 解析小数
+ * @param obj， 输入字符串
+ * @param defaultValue，默认值
+ */
+export declare const parseDecimal: (obj: string, defaultValue: number) => number;

package/es/utils/parse.mjs

@@ -0,0 +1,18 @@
+const parseNumber = (obj, defaultValue = 0) => {
+  let result = parseInt(obj, 10);
+  if (isNaN(result)) {
+    result = defaultValue || 0;
+  }
+  return result;
+};
+const parseDecimal = (obj, defaultValue) => {
+  let result = parseFloat(obj);
+  if (isNaN(result)) {
+    result = defaultValue || 0;
+  }
+  return result;
+};
+export {
+  parseDecimal,
+  parseNumber
+};

package/es/utils/props.d.ts

@@ -13,9 +13,9 @@ export declare const makeRequiredProp: <T>(type: T) => {
     type: T;
     required: true;
 };
-export declare const makeArrayProp: <T>() => {
+export declare const makeArrayProp: <T>(defaultArray?: T[]) => {
     type: PropType<T[]>;
-    default: () => never[];
+    default: () => T[];
 };
 export declare const makeNumberProp: <T>(defaultVal: T) => {
     type: NumberConstructor;

package/es/utils/props.mjs

@@ -8,9 +8,9 @@ const makeRequiredProp = (type) => ({
   type,
   required: true
 });
-const makeArrayProp = () => ({
+const makeArrayProp = (defaultArray = []) => ({
   type: Array,
-  default: () => []
+  default: () => defaultArray
 });
 const makeNumberProp = (defaultVal) => ({
   type: Number,

package/es/utils/validate.d.ts

@@ -1,4 +1,4 @@
-import { type Numeric } from './basic';
+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>;
@@ -6,4 +6,9 @@ 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 isString: (val: unknown) => val is string;
+export declare const isValidString: (val: unknown) => val is string;
+export declare const isRegExp: (val: unknown) => boolean;
 export declare const isIOS: () => boolean;
+export declare const isAndroid: () => boolean;
+export declare const isWeixin: () => boolean;

package/es/utils/validate.mjs

@@ -9,8 +9,14 @@ function isMobile(value) {
   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 isString = (val) => typeof val === "string";
+const isValidString = (val) => typeof val === "string" && val !== "";
+const isRegExp = (val) => Object.prototype.toString.call(val).replace(/\[object (\w+)\]/, "$1").toLowerCase() === "regexp";
 const isIOS = () => inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
+const isAndroid = () => inBrowser ? /android/.test(navigator.userAgent.toLowerCase()) : false;
+const isWeixin = () => inBrowser ? /micromessenger/.test(navigator.userAgent.toLowerCase()) : false;
 export {
+  isAndroid,
   isDate,
   isDef,
   isFunction,
@@ -18,5 +24,9 @@ export {
   isMobile,
   isNumeric,
   isObject,
-  isPromise
+  isPromise,
+  isRegExp,
+  isString,
+  isValidString,
+  isWeixin
 };

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

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

package/es/utils/with-install.mjs

@@ -2,8 +2,10 @@ import { camelize } from "./format.mjs";
 function withInstall(options) {
   options.install = (app) => {
     const { name } = options;
-    app.component(name, options);
-    app.component(camelize(`-${name}`), options);
+    if (name) {
+      app.component(name, options);
+      app.component(camelize(`-${name}`), options);
+    }
   };
   return options;
 }

package/es/vue-tsx-shim.d.ts

@@ -12,5 +12,12 @@ declare module 'vue' {
     onTouchmove?: EventHandler;
     onTouchstart?: EventHandler;
     onTouchcancel?: EventHandler;
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
+  }
+
+  interface HTMLAttributes {
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
   }
 }