@v-c/upload 0.0.1

package/dist/Upload.js

@@ -0,0 +1,190 @@
+import AjaxUploader_default from "./AjaxUploader.js";
+import { computed, createVNode, defineComponent, mergeDefaults, mergeProps, ref } from "vue";
+function empty() {}
+var defaults = {
+	component: "span",
+	prefixCls: "vc-upload",
+	data: {},
+	headers: {},
+	name: "file",
+	onStart: empty,
+	onError: empty,
+	onSuccess: empty,
+	multiple: false,
+	beforeUpload: void 0,
+	customRequest: void 0,
+	withCredentials: false,
+	openFileDialogOnClick: true,
+	hasControlInside: false
+};
+var Upload_default = /* @__PURE__ */ defineComponent((props, { attrs, expose, slots }) => {
+	const uploaderRef = ref();
+	const abort = (file) => {
+		uploaderRef.value?.abort(file);
+	};
+	expose({ abort });
+	const mergedProps = computed(() => ({
+		...defaults,
+		...props
+	}));
+	return () => createVNode(AjaxUploader_default, mergeProps({ "ref": uploaderRef }, mergedProps.value, attrs), { default: () => [slots.default?.()] });
+}, {
+	props: /* @__PURE__ */ mergeDefaults({
+		name: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		style: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		className: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		component: {
+			type: [
+				Object,
+				Function,
+				String
+			],
+			required: false,
+			default: void 0
+		},
+		action: {
+			type: [String, Function],
+			required: false,
+			default: void 0
+		},
+		method: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		directory: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		data: {
+			type: [Object, Function],
+			required: false,
+			default: void 0
+		},
+		headers: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		accept: {
+			type: [String, Object],
+			required: false,
+			default: void 0
+		},
+		multiple: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		onBatchStart: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onStart: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onError: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onSuccess: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onProgress: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		beforeUpload: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		customRequest: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		withCredentials: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		openFileDialogOnClick: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		prefixCls: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		id: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		onMouseEnter: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseLeave: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onClick: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		classNames: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		styles: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		hasControlInside: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		pastable: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		}
+	}, defaults),
+	name: "Upload"
+});
+export { Upload_default as default };

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,21 @@
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, 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));
+exports.__toESM = __toESM;

package/dist/attrAccept.cjs

@@ -0,0 +1,34 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("./_virtual/rolldown_runtime.cjs");
+let _v_c_util = require("@v-c/util");
+var attrAccept_default = (file, acceptedFiles) => {
+	if (file && acceptedFiles) {
+		const acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(",");
+		const fileName = file.name || "";
+		const mimeType = file.type || "";
+		const baseMimeType = mimeType.replace(/\/.*$/, "");
+		return acceptedFilesArray.some((type) => {
+			const validType = type.trim();
+			if (/^\*(\/\*)?$/.test(type)) return true;
+			if (validType.charAt(0) === ".") {
+				const lowerFileName = fileName.toLowerCase();
+				const lowerType = validType.toLowerCase();
+				let affixList = [lowerType];
+				if (lowerType === ".jpg" || lowerType === ".jpeg") affixList = [".jpg", ".jpeg"];
+				return affixList.some((affix) => lowerFileName.endsWith(affix));
+			}
+			if (/\/\*$/.test(validType)) return baseMimeType === validType.replace(/\/.*$/, "");
+			if (mimeType === validType) return true;
+			if (/^\w+$/.test(validType)) {
+				(0, _v_c_util.warning)(false, `Upload takes an invalidate 'accept' type '${validType}'.Skip for check.`);
+				return true;
+			}
+			return false;
+		});
+	}
+	return true;
+};
+exports.default = attrAccept_default;

package/dist/attrAccept.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (file: File, acceptedFiles: undefined | string | string[]) => boolean;
+export default _default;

package/dist/attrAccept.js

@@ -0,0 +1,29 @@
+import { warning } from "@v-c/util";
+var attrAccept_default = (file, acceptedFiles) => {
+	if (file && acceptedFiles) {
+		const acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(",");
+		const fileName = file.name || "";
+		const mimeType = file.type || "";
+		const baseMimeType = mimeType.replace(/\/.*$/, "");
+		return acceptedFilesArray.some((type) => {
+			const validType = type.trim();
+			if (/^\*(\/\*)?$/.test(type)) return true;
+			if (validType.charAt(0) === ".") {
+				const lowerFileName = fileName.toLowerCase();
+				const lowerType = validType.toLowerCase();
+				let affixList = [lowerType];
+				if (lowerType === ".jpg" || lowerType === ".jpeg") affixList = [".jpg", ".jpeg"];
+				return affixList.some((affix) => lowerFileName.endsWith(affix));
+			}
+			if (/\/\*$/.test(validType)) return baseMimeType === validType.replace(/\/.*$/, "");
+			if (mimeType === validType) return true;
+			if (/^\w+$/.test(validType)) {
+				warning(false, `Upload takes an invalidate 'accept' type '${validType}'.Skip for check.`);
+				return true;
+			}
+			return false;
+		});
+	}
+	return true;
+};
+export { attrAccept_default as default };

package/dist/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_Upload = require("./Upload.cjs");
+var src_default = require_Upload.default;
+exports.default = src_default;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { AcceptConfig, UploadProps, UploadRequestOption, VcFile } from './interface';
+import { default as Upload } from './Upload';
+export type { AcceptConfig, UploadProps, UploadRequestOption, VcFile };
+export default Upload;

package/dist/index.js

@@ -0,0 +1,3 @@
+import Upload_default from "./Upload.js";
+var src_default = Upload_default;
+export { src_default as default };

package/dist/interface.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/interface.d.ts

@@ -0,0 +1,82 @@
+import { Component, CSSProperties } from 'vue';
+export interface VcFile extends File {
+    uid: string;
+}
+export type BeforeUploadFileType = File | Blob | boolean | string;
+export type Action = string | ((file: VcFile) => string | PromiseLike<string>);
+export interface AcceptConfig {
+    format: string;
+    filter?: 'native' | ((file: VcFile) => boolean);
+}
+export type UploadRequestMethod = 'POST' | 'PUT' | 'PATCH' | 'post' | 'put' | 'patch';
+export type UploadRequestHeader = Record<string, string>;
+export type UploadRequestFile = Exclude<BeforeUploadFileType, File | boolean> | VcFile;
+export interface UploadRequestError extends Error {
+    status?: number;
+    method?: UploadRequestMethod;
+    url?: string;
+}
+export interface UploadProgressEvent extends Partial<ProgressEvent> {
+    percent?: number;
+}
+export interface AjaxUploaderExpose {
+    abort: (file: any) => void;
+}
+export interface UploadRequestOption<T = any> {
+    onProgress?: (event: UploadProgressEvent, file?: UploadRequestFile) => void;
+    onError?: (event: UploadRequestError | ProgressEvent, body?: T) => void;
+    onSuccess?: (body: T, fileOrXhr?: UploadRequestFile | XMLHttpRequest) => void;
+    data?: Record<string, unknown>;
+    filename?: string;
+    file: UploadRequestFile;
+    withCredentials?: boolean;
+    action: string;
+    headers?: UploadRequestHeader;
+    method: UploadRequestMethod;
+}
+export type CustomUploadRequestOption = (option: UploadRequestOption, info: {
+    defaultRequest: (option: UploadRequestOption) => {
+        abort: () => void;
+    } | void;
+}) => void | {
+    abort: () => void;
+};
+export interface UploadProps {
+    name?: string;
+    style?: CSSProperties;
+    className?: string;
+    disabled?: boolean;
+    component?: Component | string;
+    action?: Action;
+    method?: UploadRequestMethod;
+    directory?: boolean;
+    data?: Record<string, unknown> | ((file: VcFile | string | Blob) => Record<string, unknown>);
+    headers?: UploadRequestHeader;
+    accept?: string | AcceptConfig;
+    multiple?: boolean;
+    onBatchStart?: (fileList: {
+        file: VcFile;
+        parsedFile: Exclude<BeforeUploadFileType, boolean> | null;
+    }[]) => void;
+    onStart?: (file: VcFile) => void;
+    onError?: (error: Error, ret: Record<string, unknown>, file: VcFile | null) => void;
+    onSuccess?: (response: Record<string, unknown>, file: VcFile | null, xhr: XMLHttpRequest) => void;
+    onProgress?: (event: UploadProgressEvent, file: VcFile | null) => void;
+    beforeUpload?: (file: VcFile, FileList: VcFile[]) => BeforeUploadFileType | Promise<void | BeforeUploadFileType> | void;
+    customRequest?: CustomUploadRequestOption;
+    withCredentials?: boolean;
+    openFileDialogOnClick?: boolean;
+    prefixCls?: string;
+    id?: string;
+    onMouseEnter?: (e: MouseEvent) => void;
+    onMouseLeave?: (e: MouseEvent) => void;
+    onClick?: (e: MouseEvent | KeyboardEvent) => void;
+    classNames?: {
+        input?: string;
+    };
+    styles?: {
+        input?: CSSProperties;
+    };
+    hasControlInside?: boolean;
+    pastable?: boolean;
+}

package/dist/request.cjs

@@ -0,0 +1,60 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+function getError(option, xhr) {
+	const msg = `cannot ${option.method} ${option.action} ${xhr.status}'`;
+	const err = new Error(msg);
+	err.status = xhr.status;
+	err.method = option.method;
+	err.url = option.action;
+	return err;
+}
+function getBody(xhr) {
+	const text = xhr.responseText || xhr.response;
+	if (!text) return text;
+	try {
+		return JSON.parse(text);
+	} catch (e) {
+		return text;
+	}
+}
+function upload(option) {
+	const xhr = new XMLHttpRequest();
+	if (option.onProgress && xhr.upload) xhr.upload.onprogress = function progress(e) {
+		if (e.total > 0) e.percent = e.loaded / e.total * 100;
+		option.onProgress?.(e);
+	};
+	const formData = new FormData();
+	if (option.data) Object.keys(option.data).forEach((key) => {
+		const value = option.data[key];
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				formData.append(`${key}[]`, item);
+			});
+			return;
+		}
+		formData.append(key, value);
+	});
+	if (option.file instanceof Blob) formData.append(option.filename, option.file, option.file.name);
+	else formData.append(option.filename, option.file);
+	xhr.onerror = function error(e) {
+		option.onError?.(e);
+	};
+	xhr.onload = function onload() {
+		if (xhr.status < 200 || xhr.status >= 300) return option.onError?.(getError(option, xhr), getBody(xhr));
+		return option.onSuccess?.(getBody(xhr), xhr);
+	};
+	xhr.open(option.method, option.action, true);
+	if (option.withCredentials && "withCredentials" in xhr) xhr.withCredentials = true;
+	const headers = option.headers || {};
+	if (headers["X-Requested-With"] !== null) xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+	Object.keys(headers).forEach((h) => {
+		if (headers[h] !== null) xhr.setRequestHeader(h, headers[h]);
+	});
+	xhr.send(formData);
+	return { abort() {
+		xhr.abort();
+	} };
+}
+exports.default = upload;

package/dist/request.d.ts

@@ -0,0 +1,4 @@
+import { UploadRequestOption } from './interface';
+export default function upload(option: UploadRequestOption): {
+    abort(): void;
+};

package/dist/request.js

@@ -0,0 +1,56 @@
+function getError(option, xhr) {
+	const msg = `cannot ${option.method} ${option.action} ${xhr.status}'`;
+	const err = new Error(msg);
+	err.status = xhr.status;
+	err.method = option.method;
+	err.url = option.action;
+	return err;
+}
+function getBody(xhr) {
+	const text = xhr.responseText || xhr.response;
+	if (!text) return text;
+	try {
+		return JSON.parse(text);
+	} catch (e) {
+		return text;
+	}
+}
+function upload(option) {
+	const xhr = new XMLHttpRequest();
+	if (option.onProgress && xhr.upload) xhr.upload.onprogress = function progress(e) {
+		if (e.total > 0) e.percent = e.loaded / e.total * 100;
+		option.onProgress?.(e);
+	};
+	const formData = new FormData();
+	if (option.data) Object.keys(option.data).forEach((key) => {
+		const value = option.data[key];
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				formData.append(`${key}[]`, item);
+			});
+			return;
+		}
+		formData.append(key, value);
+	});
+	if (option.file instanceof Blob) formData.append(option.filename, option.file, option.file.name);
+	else formData.append(option.filename, option.file);
+	xhr.onerror = function error(e) {
+		option.onError?.(e);
+	};
+	xhr.onload = function onload() {
+		if (xhr.status < 200 || xhr.status >= 300) return option.onError?.(getError(option, xhr), getBody(xhr));
+		return option.onSuccess?.(getBody(xhr), xhr);
+	};
+	xhr.open(option.method, option.action, true);
+	if (option.withCredentials && "withCredentials" in xhr) xhr.withCredentials = true;
+	const headers = option.headers || {};
+	if (headers["X-Requested-With"] !== null) xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+	Object.keys(headers).forEach((h) => {
+		if (headers[h] !== null) xhr.setRequestHeader(h, headers[h]);
+	});
+	xhr.send(formData);
+	return { abort() {
+		xhr.abort();
+	} };
+}
+export { upload as default };

package/dist/traverseFileTree.cjs

@@ -0,0 +1,55 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+async function traverseFileTree(files, isAccepted) {
+	const flattenFileList = [];
+	const progressFileList = [];
+	files.forEach((file) => progressFileList.push(file.webkitGetAsEntry()));
+	async function readDirectory(directory) {
+		const dirReader = directory.createReader();
+		const entries = [];
+		while (true) {
+			const results = await new Promise((resolve) => {
+				dirReader.readEntries(resolve, () => resolve([]));
+			});
+			const n = results.length;
+			if (!n) break;
+			for (let i = 0; i < n; i++) entries.push(results[i]);
+		}
+		return entries;
+	}
+	async function readFile(item) {
+		return new Promise((resolve) => {
+			item.file((file) => {
+				if (isAccepted(file)) {
+					if (item.fullPath && !file.webkitRelativePath) {
+						Object.defineProperties(file, { webkitRelativePath: { writable: true } });
+						file.webkitRelativePath = item.fullPath.replace(/^\//, "");
+						Object.defineProperties(file, { webkitRelativePath: { writable: false } });
+					}
+					resolve(file);
+				} else resolve(null);
+			});
+		});
+	}
+	const _traverseFileTree = async (item, path) => {
+		if (!item) return;
+		item.path = path || "";
+		if (item.isFile) {
+			const file = await readFile(item);
+			if (file) flattenFileList.push(file);
+		} else if (item.isDirectory) {
+			const entries = await readDirectory(item);
+			progressFileList.push(...entries);
+		}
+	};
+	let wipIndex = 0;
+	while (wipIndex < progressFileList.length) {
+		await _traverseFileTree(progressFileList[wipIndex]);
+		wipIndex++;
+	}
+	return flattenFileList;
+}
+var traverseFileTree_default = traverseFileTree;
+exports.default = traverseFileTree_default;

package/dist/traverseFileTree.d.ts

@@ -0,0 +1,17 @@
+import { VcFile } from './interface';
+interface InternalDataTransferItem extends DataTransferItem {
+    isFile: boolean;
+    file: (cd: (file: VcFile & {
+        webkitRelativePath?: string;
+    }) => void) => void;
+    createReader: () => any;
+    fullPath: string;
+    isDirectory: boolean;
+    name: string;
+    path: string;
+}
+type InternalFile = VcFile & {
+    webkitRelativePath?: string;
+};
+declare function traverseFileTree(files: InternalDataTransferItem[], isAccepted: (file: InternalFile) => boolean): Promise<InternalFile[]>;
+export default traverseFileTree;

package/dist/traverseFileTree.js

@@ -0,0 +1,51 @@
+async function traverseFileTree(files, isAccepted) {
+	const flattenFileList = [];
+	const progressFileList = [];
+	files.forEach((file) => progressFileList.push(file.webkitGetAsEntry()));
+	async function readDirectory(directory) {
+		const dirReader = directory.createReader();
+		const entries = [];
+		while (true) {
+			const results = await new Promise((resolve) => {
+				dirReader.readEntries(resolve, () => resolve([]));
+			});
+			const n = results.length;
+			if (!n) break;
+			for (let i = 0; i < n; i++) entries.push(results[i]);
+		}
+		return entries;
+	}
+	async function readFile(item) {
+		return new Promise((resolve) => {
+			item.file((file) => {
+				if (isAccepted(file)) {
+					if (item.fullPath && !file.webkitRelativePath) {
+						Object.defineProperties(file, { webkitRelativePath: { writable: true } });
+						file.webkitRelativePath = item.fullPath.replace(/^\//, "");
+						Object.defineProperties(file, { webkitRelativePath: { writable: false } });
+					}
+					resolve(file);
+				} else resolve(null);
+			});
+		});
+	}
+	const _traverseFileTree = async (item, path) => {
+		if (!item) return;
+		item.path = path || "";
+		if (item.isFile) {
+			const file = await readFile(item);
+			if (file) flattenFileList.push(file);
+		} else if (item.isDirectory) {
+			const entries = await readDirectory(item);
+			progressFileList.push(...entries);
+		}
+	};
+	let wipIndex = 0;
+	while (wipIndex < progressFileList.length) {
+		await _traverseFileTree(progressFileList[wipIndex]);
+		wipIndex++;
+	}
+	return flattenFileList;
+}
+var traverseFileTree_default = traverseFileTree;
+export { traverseFileTree_default as default };

package/dist/uid.cjs

@@ -0,0 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+var now = +/* @__PURE__ */ new Date();
+var index = 0;
+function uid() {
+	return `vc-upload-${now}-${++index}`;
+}
+exports.default = uid;

package/dist/uid.d.ts

@@ -0,0 +1 @@
+export default function uid(): string;

package/dist/uid.js

@@ -0,0 +1,6 @@
+var now = +/* @__PURE__ */ new Date();
+var index = 0;
+function uid() {
+	return `vc-upload-${now}-${++index}`;
+}
+export { uid as default };