zartui 3.0.2 → 3.0.4

package/lib/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/lib/uploader/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, {
+  Uploader: () => Uploader,
+  default: () => stdin_default,
+  uploaderProps: () => import_Uploader2.uploaderProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_Uploader = __toESM(require("./Uploader"));
+var import_Uploader2 = require("./Uploader");
+const Uploader = (0, import_utils.withInstall)(import_Uploader.default);
+var stdin_default = Uploader;

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

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

package/lib/uploader/style/index.js

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

package/lib/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/lib/uploader/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/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/lib/uploader/utils.js

@@ -0,0 +1,88 @@
+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, {
+  bem: () => bem,
+  filterFiles: () => filterFiles,
+  isImageFile: () => isImageFile,
+  isImageUrl: () => isImageUrl,
+  isOversize: () => isOversize,
+  name: () => name,
+  readFileContent: () => readFileContent,
+  t: () => t
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+const [name, bem, t] = (0, import_utils.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 (0, import_utils.toArray)(items).some((item) => {
+    if (item.file) {
+      if ((0, import_utils.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;
+}

package/lib/utils/basic.js

@@ -26,6 +26,7 @@ __export(stdin_exports, {
   toArray: () => toArray
 });
 module.exports = __toCommonJS(stdin_exports);
+var import_validate = require("./validate");
 function noop() {
 }
 const extend = Object.assign;
@@ -35,7 +36,7 @@ function get(object, path) {
   let result = object;
   keys.forEach((key) => {
     var _a;
-    result = (_a = result[key]) != null ? _a : "";
+    result = (0, import_validate.isObject)(result) ? (_a = result[key]) != null ? _a : "" : "";
   });
   return result;
 }

package/lib/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,6 @@ 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>;
+export declare const LONG_PRESS_START_TIME = 500;

package/lib/utils/constant.js

@@ -24,7 +24,10 @@ __export(stdin_exports, {
   BORDER_TOP: () => BORDER_TOP,
   BORDER_TOP_BOTTOM: () => BORDER_TOP_BOTTOM,
   BORDER_UNSET_TOP_BOTTOM: () => BORDER_UNSET_TOP_BOTTOM,
-  HAPTICS_FEEDBACK: () => HAPTICS_FEEDBACK
+  ELLIPSIS: () => ELLIPSIS,
+  FORM_KEY: () => FORM_KEY,
+  HAPTICS_FEEDBACK: () => HAPTICS_FEEDBACK,
+  LONG_PRESS_START_TIME: () => LONG_PRESS_START_TIME
 });
 module.exports = __toCommonJS(stdin_exports);
 const BORDER = "zt-hairline";
@@ -35,3 +38,6 @@ 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");
+const LONG_PRESS_START_TIME = 500;

package/lib/utils/create.js

@@ -48,7 +48,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/lib/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/lib/utils/mount-component.d.ts

@@ -9,6 +9,6 @@ export declare function usePopupState(): {
     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, {}>>;
+    instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
     unmount(): void;
 };

package/lib/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/lib/utils/parse.js

@@ -0,0 +1,37 @@
+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, {
+  parseDecimal: () => parseDecimal,
+  parseNumber: () => parseNumber
+});
+module.exports = __toCommonJS(stdin_exports);
+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;
+};

package/lib/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/lib/utils/props.js

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

package/lib/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/lib/utils/validate.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var stdin_exports = {};
 __export(stdin_exports, {
+  isAndroid: () => isAndroid,
   isDate: () => isDate,
   isDef: () => isDef,
   isFunction: () => isFunction,
@@ -24,7 +25,11 @@ __export(stdin_exports, {
   isMobile: () => isMobile,
   isNumeric: () => isNumeric,
   isObject: () => isObject,
-  isPromise: () => isPromise
+  isPromise: () => isPromise,
+  isRegExp: () => isRegExp,
+  isString: () => isString,
+  isValidString: () => isValidString,
+  isWeixin: () => isWeixin
 });
 module.exports = __toCommonJS(stdin_exports);
 var import_basic = require("./basic");
@@ -38,4 +43,9 @@ 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 = () => import_basic.inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
+const isAndroid = () => import_basic.inBrowser ? /android/.test(navigator.userAgent.toLowerCase()) : false;
+const isWeixin = () => import_basic.inBrowser ? /micromessenger/.test(navigator.userAgent.toLowerCase()) : false;

package/lib/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/lib/utils/with-install.js

@@ -24,8 +24,10 @@ var import_format = require("./format");
 function withInstall(options) {
   options.install = (app) => {
     const { name } = options;
-    app.component(name, options);
-    app.component((0, import_format.camelize)(`-${name}`), options);
+    if (name) {
+      app.component(name, options);
+      app.component((0, import_format.camelize)(`-${name}`), options);
+    }
   };
   return options;
 }

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