@nocobase/plugin-file-manager 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/node_modules/multer-aliyun-oss/setup-sandbox.js

@@ -0,0 +1,545 @@
+/* global host, bridge, data, context */
+
+'use strict';
+
+const {
+	Object: localObject,
+	Array: localArray,
+	Error: LocalError,
+	Reflect: localReflect,
+	Proxy: LocalProxy,
+	WeakMap: LocalWeakMap,
+	Function: localFunction,
+	Promise: localPromise,
+	eval: localEval
+} = global;
+
+const {
+	freeze: localObjectFreeze
+} = localObject;
+
+const {
+	getPrototypeOf: localReflectGetPrototypeOf,
+	apply: localReflectApply,
+	construct: localReflectConstruct,
+	deleteProperty: localReflectDeleteProperty,
+	has: localReflectHas,
+	defineProperty: localReflectDefineProperty,
+	setPrototypeOf: localReflectSetPrototypeOf,
+	getOwnPropertyDescriptor: localReflectGetOwnPropertyDescriptor
+} = localReflect;
+
+const {
+	isArray: localArrayIsArray
+} = localArray;
+
+const {
+	ensureThis,
+	ReadOnlyHandler,
+	from,
+	fromWithFactory,
+	readonlyFactory,
+	connect,
+	addProtoMapping,
+	VMError,
+	ReadOnlyMockHandler
+} = bridge;
+
+const {
+	allowAsync,
+	GeneratorFunction,
+	AsyncFunction,
+	AsyncGeneratorFunction
+} = data;
+
+const {
+	get: localWeakMapGet,
+	set: localWeakMapSet
+} = LocalWeakMap.prototype;
+
+function localUnexpected() {
+	return new VMError('Should not happen');
+}
+
+// global is originally prototype of host.Object so it can be used to climb up from the sandbox.
+if (!localReflectSetPrototypeOf(context, localObject.prototype)) throw localUnexpected();
+
+Object.defineProperties(global, {
+	global: {value: global, writable: true, configurable: true, enumerable: true},
+	globalThis: {value: global, writable: true, configurable: true},
+	GLOBAL: {value: global, writable: true, configurable: true},
+	root: {value: global, writable: true, configurable: true},
+	Error: {value: LocalError}
+});
+
+if (!localReflectDefineProperty(global, 'VMError', {
+	__proto__: null,
+	value: VMError,
+	writable: true,
+	enumerable: false,
+	configurable: true
+})) throw localUnexpected();
+
+// Fixes buffer unsafe allocation
+/* eslint-disable no-use-before-define */
+class BufferHandler extends ReadOnlyHandler {
+
+	apply(target, thiz, args) {
+		if (args.length > 0 && typeof args[0] === 'number') {
+			return LocalBuffer.alloc(args[0]);
+		}
+		return localReflectApply(LocalBuffer.from, LocalBuffer, args);
+	}
+
+	construct(target, args, newTarget) {
+		if (args.length > 0 && typeof args[0] === 'number') {
+			return LocalBuffer.alloc(args[0]);
+		}
+		return localReflectApply(LocalBuffer.from, LocalBuffer, args);
+	}
+
+}
+/* eslint-enable no-use-before-define */
+
+const LocalBuffer = fromWithFactory(obj => new BufferHandler(obj), host.Buffer);
+
+
+if (!localReflectDefineProperty(global, 'Buffer', {
+	__proto__: null,
+	value: LocalBuffer,
+	writable: true,
+	enumerable: false,
+	configurable: true
+})) throw localUnexpected();
+
+addProtoMapping(LocalBuffer.prototype, host.Buffer.prototype, 'Uint8Array');
+
+/**
+ *
+ * @param {*} size Size of new buffer
+ * @this LocalBuffer
+ * @return {LocalBuffer}
+ */
+function allocUnsafe(size) {
+	return LocalBuffer.alloc(size);
+}
+
+connect(allocUnsafe, host.Buffer.allocUnsafe);
+
+/**
+ *
+ * @param {*} size Size of new buffer
+ * @this LocalBuffer
+ * @return {LocalBuffer}
+ */
+function allocUnsafeSlow(size) {
+	return LocalBuffer.alloc(size);
+}
+
+connect(allocUnsafeSlow, host.Buffer.allocUnsafeSlow);
+
+/**
+ * Replacement for Buffer inspect
+ *
+ * @param {*} recurseTimes
+ * @param {*} ctx
+ * @this LocalBuffer
+ * @return {string}
+ */
+function inspect(recurseTimes, ctx) {
+	// Mimic old behavior, could throw but didn't pass a test.
+	const max = host.INSPECT_MAX_BYTES;
+	const actualMax = Math.min(max, this.length);
+	const remaining = this.length - max;
+	let str = this.hexSlice(0, actualMax).replace(/(.{2})/g, '$1 ').trim();
+	if (remaining > 0) str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+	return `<${this.constructor.name} ${str}>`;
+}
+
+connect(inspect, host.Buffer.prototype.inspect);
+
+connect(localFunction.prototype.bind, host.Function.prototype.bind);
+
+connect(localObject.prototype.__defineGetter__, host.Object.prototype.__defineGetter__);
+connect(localObject.prototype.__defineSetter__, host.Object.prototype.__defineSetter__);
+connect(localObject.prototype.__lookupGetter__, host.Object.prototype.__lookupGetter__);
+connect(localObject.prototype.__lookupSetter__, host.Object.prototype.__lookupSetter__);
+
+/*
+ * PrepareStackTrace sanitization
+ */
+
+const oldPrepareStackTraceDesc = localReflectGetOwnPropertyDescriptor(LocalError, 'prepareStackTrace');
+
+let currentPrepareStackTrace = LocalError.prepareStackTrace;
+const wrappedPrepareStackTrace = new LocalWeakMap();
+if (typeof currentPrepareStackTrace === 'function') {
+	wrappedPrepareStackTrace.set(currentPrepareStackTrace, currentPrepareStackTrace);
+}
+
+let OriginalCallSite;
+LocalError.prepareStackTrace = (e, sst) => {
+	OriginalCallSite = sst[0].constructor;
+};
+new LocalError().stack;
+if (typeof OriginalCallSite === 'function') {
+	LocalError.prepareStackTrace = undefined;
+
+	function makeCallSiteGetters(list) {
+		const callSiteGetters = [];
+		for (let i=0; i<list.length; i++) {
+			const name = list[i];
+			const func = OriginalCallSite.prototype[name];
+			callSiteGetters[i] = {__proto__: null,
+				name,
+				propName: '_' + name,
+				func: (thiz) => {
+					return localReflectApply(func, thiz, []);
+				}
+			};
+		}
+		return callSiteGetters;
+	}
+
+	function applyCallSiteGetters(thiz, callSite, getters) {
+		for (let i=0; i<getters.length; i++) {
+			const getter = getters[i];
+			localReflectDefineProperty(thiz, getter.propName, {
+				__proto__: null,
+				value: getter.func(callSite)
+			});
+		}
+	}
+
+	const callSiteGetters = makeCallSiteGetters([
+		'getTypeName',
+		'getFunctionName',
+		'getMethodName',
+		'getFileName',
+		'getLineNumber',
+		'getColumnNumber',
+		'getEvalOrigin',
+		'isToplevel',
+		'isEval',
+		'isNative',
+		'isConstructor',
+		'isAsync',
+		'isPromiseAll',
+		'getPromiseIndex'
+	]);
+
+	class CallSite {
+		constructor(callSite) {
+			applyCallSiteGetters(this, callSite, callSiteGetters);
+		}
+		getThis() {
+			return undefined;
+		}
+		getFunction() {
+			return undefined;
+		}
+		toString() {
+			return 'CallSite {}';
+		}
+	}
+
+
+	for (let i=0; i<callSiteGetters.length; i++) {
+		const name = callSiteGetters[i].name;
+		const funcProp = localReflectGetOwnPropertyDescriptor(OriginalCallSite.prototype, name);
+		if (!funcProp) continue;
+		const propertyName = callSiteGetters[i].propName;
+		const func = {func() {
+			return this[propertyName];
+		}}.func;
+		const nameProp = localReflectGetOwnPropertyDescriptor(func, 'name');
+		if (!nameProp) throw localUnexpected();
+		nameProp.value = name;
+		if (!localReflectDefineProperty(func, 'name', nameProp)) throw localUnexpected();
+		funcProp.value = func;
+		if (!localReflectDefineProperty(CallSite.prototype, name, funcProp)) throw localUnexpected();
+	}
+
+	if (!localReflectDefineProperty(LocalError, 'prepareStackTrace', {
+		configurable: false,
+		enumerable: false,
+		get() {
+			return currentPrepareStackTrace;
+		},
+		set(value) {
+			if (typeof(value) !== 'function') {
+				currentPrepareStackTrace = value;
+				return;
+			}
+			const wrapped = localReflectApply(localWeakMapGet, wrappedPrepareStackTrace, [value]);
+			if (wrapped) {
+				currentPrepareStackTrace = wrapped;
+				return;
+			}
+			const newWrapped = (error, sst) => {
+				const sandboxSst = ensureThis(sst);
+				if (localArrayIsArray(sst)) {
+					if (sst === sandboxSst) {
+						for (let i=0; i < sst.length; i++) {
+							const cs = sst[i];
+							if (typeof cs === 'object' && localReflectGetPrototypeOf(cs) === OriginalCallSite.prototype) {
+								sst[i] = new CallSite(cs);
+							}
+						}
+					} else {
+						sst = [];
+						for (let i=0; i < sandboxSst.length; i++) {
+							const cs = sandboxSst[i];
+							localReflectDefineProperty(sst, i, {
+								__proto__: null,
+								value: new CallSite(cs),
+								enumerable: true,
+								configurable: true,
+								writable: true
+							});
+						}
+					}
+				} else {
+					sst = sandboxSst;
+				}
+				return value(error, sst);
+			};
+			localReflectApply(localWeakMapSet, wrappedPrepareStackTrace, [value, newWrapped]);
+			localReflectApply(localWeakMapSet, wrappedPrepareStackTrace, [newWrapped, newWrapped]);
+			currentPrepareStackTrace = newWrapped;
+		}
+	})) throw localUnexpected();
+} else if (oldPrepareStackTraceDesc) {
+	localReflectDefineProperty(LocalError, 'prepareStackTrace', oldPrepareStackTraceDesc);
+} else {
+	localReflectDeleteProperty(LocalError, 'prepareStackTrace');
+}
+
+/*
+ * Exception sanitization
+ */
+
+const withProxy = localObjectFreeze({
+	__proto__: null,
+	has(target, key) {
+		if (key === host.INTERNAL_STATE_NAME) return false;
+		return localReflectHas(target, key);
+	}
+});
+
+const interanState = localObjectFreeze({
+	__proto__: null,
+	wrapWith(x) {
+		if (x === null || x === undefined) return x;
+		return new LocalProxy(localObject(x), withProxy);
+	},
+	handleException: ensureThis,
+	import(what) {
+		throw new VMError('Dynamic Import not supported');
+	}
+});
+
+if (!localReflectDefineProperty(global, host.INTERNAL_STATE_NAME, {
+	__proto__: null,
+	configurable: false,
+	enumerable: false,
+	writable: false,
+	value: interanState
+})) throw localUnexpected();
+
+/*
+ * Eval sanitization
+ */
+
+function throwAsync() {
+	return new VMError('Async not available');
+}
+
+function makeFunction(inputArgs, isAsync, isGenerator) {
+	const lastArgs = inputArgs.length - 1;
+	let code = lastArgs >= 0 ? `${inputArgs[lastArgs]}` : '';
+	let args = lastArgs > 0 ? `${inputArgs[0]}` : '';
+	for (let i = 1; i < lastArgs; i++) {
+		args += `,${inputArgs[i]}`;
+	}
+	try {
+		code = host.transformAndCheck(args, code, isAsync, isGenerator, allowAsync);
+	} catch (e) {
+		throw bridge.from(e);
+	}
+	return localEval(code);
+}
+
+const FunctionHandler = {
+	__proto__: null,
+	apply(target, thiz, args) {
+		return makeFunction(args, this.isAsync, this.isGenerator);
+	},
+	construct(target, args, newTarget) {
+		return makeFunction(args, this.isAsync, this.isGenerator);
+	}
+};
+
+const EvalHandler = {
+	__proto__: null,
+	apply(target, thiz, args) {
+		if (args.length === 0) return undefined;
+		let code = `${args[0]}`;
+		try {
+			code = host.transformAndCheck(null, code, false, false, allowAsync);
+		} catch (e) {
+			throw bridge.from(e);
+		}
+		return localEval(code);
+	}
+};
+
+const AsyncErrorHandler = {
+	__proto__: null,
+	apply(target, thiz, args) {
+		throw throwAsync();
+	},
+	construct(target, args, newTarget) {
+		throw throwAsync();
+	}
+};
+
+function makeCheckFunction(isAsync, isGenerator) {
+	if (isAsync && !allowAsync) return AsyncErrorHandler;
+	return {
+		__proto__: FunctionHandler,
+		isAsync,
+		isGenerator
+	};
+}
+
+function overrideWithProxy(obj, prop, value, handler) {
+	const proxy = new LocalProxy(value, handler);
+	if (!localReflectDefineProperty(obj, prop, {__proto__: null, value: proxy})) throw localUnexpected();
+	return proxy;
+}
+
+const proxiedFunction = overrideWithProxy(localFunction.prototype, 'constructor', localFunction, makeCheckFunction(false, false));
+if (GeneratorFunction) {
+	if (!localReflectSetPrototypeOf(GeneratorFunction, proxiedFunction)) throw localUnexpected();
+	overrideWithProxy(GeneratorFunction.prototype, 'constructor', GeneratorFunction, makeCheckFunction(false, true));
+}
+if (AsyncFunction) {
+	if (!localReflectSetPrototypeOf(AsyncFunction, proxiedFunction)) throw localUnexpected();
+	overrideWithProxy(AsyncFunction.prototype, 'constructor', AsyncFunction, makeCheckFunction(true, false));
+}
+if (AsyncGeneratorFunction) {
+	if (!localReflectSetPrototypeOf(AsyncGeneratorFunction, proxiedFunction)) throw localUnexpected();
+	overrideWithProxy(AsyncGeneratorFunction.prototype, 'constructor', AsyncGeneratorFunction, makeCheckFunction(true, true));
+}
+
+function makeSafeHandlerArgs(args) {
+	const sArgs = ensureThis(args);
+	if (sArgs === args) return args;
+	const a = [];
+	for (let i=0; i < sArgs.length; i++) {
+		localReflectDefineProperty(a, i, {
+			__proto__: null,
+			value: sArgs[i],
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	}
+	return a;
+}
+
+const makeSafeArgs = Object.freeze({
+	__proto__: null,
+	apply(target, thiz, args) {
+		return localReflectApply(target, thiz, makeSafeHandlerArgs(args));
+	},
+	construct(target, args, newTarget) {
+		return localReflectConstruct(target, makeSafeHandlerArgs(args), newTarget);
+	}
+});
+
+const proxyHandlerHandler = Object.freeze({
+	__proto__: null,
+	get(target, name, receiver) {
+		const value = target.handler[name];
+		if (typeof value !== 'function') return value;
+		return new LocalProxy(value, makeSafeArgs);
+	}
+});
+
+function wrapProxyHandler(args) {
+	if (args.length < 2) return args;
+	const handler = args[1];
+	args[1] = new LocalProxy({__proto__: null, handler}, proxyHandlerHandler);
+	return args;
+}
+
+const proxyHandler = Object.freeze({
+	__proto__: null,
+	apply(target, thiz, args) {
+		return localReflectApply(target, thiz, wrapProxyHandler(args));
+	},
+	construct(target, args, newTarget) {
+		return localReflectConstruct(target, wrapProxyHandler(args), newTarget);
+	}
+});
+
+const proxiedProxy = new LocalProxy(LocalProxy, proxyHandler);
+
+overrideWithProxy(LocalProxy, 'revocable', LocalProxy.revocable, proxyHandler);
+
+global.Proxy = proxiedProxy;
+global.Function = proxiedFunction;
+global.eval = new LocalProxy(localEval, EvalHandler);
+
+/*
+ * Promise sanitization
+ */
+
+if (localPromise) {
+
+	const PromisePrototype = localPromise.prototype;
+
+	if (!allowAsync) {
+
+		overrideWithProxy(PromisePrototype, 'then', PromisePrototype.then, AsyncErrorHandler);
+		// This seems not to work, and will produce
+		// UnhandledPromiseRejectionWarning: TypeError: Method Promise.prototype.then called on incompatible receiver [object Object].
+		// This is likely caused since the host.Promise.prototype.then cannot use the VM Proxy object.
+		// Contextify.connect(host.Promise.prototype.then, Promise.prototype.then);
+
+	} else {
+
+		overrideWithProxy(PromisePrototype, 'then', PromisePrototype.then, {
+			__proto__: null,
+			apply(target, thiz, args) {
+				if (args.length > 1) {
+					const onRejected = args[1];
+					if (typeof onRejected === 'function') {
+						args[1] = function wrapper(error) {
+							error = ensureThis(error);
+							return localReflectApply(onRejected, this, [error]);
+						};
+					}
+				}
+				return localReflectApply(target, thiz, args);
+			}
+		});
+
+	}
+
+}
+
+function readonly(other, mock) {
+	// Note: other@other(unsafe) mock@other(unsafe) returns@this(unsafe) throws@this(unsafe)
+	if (!mock) return fromWithFactory(readonlyFactory, other);
+	const tmock = from(mock);
+	return fromWithFactory(obj=>new ReadOnlyMockHandler(obj, tmock), other);
+}
+
+return {
+	__proto__: null,
+	readonly,
+	global
+};

package/dist/node_modules/multer-cos/LICENSE

@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2009-2014 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2013-2014 Roman Shtylman <shtylman+expressjs@gmail.com>
+Copyright (c) 2014-2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/node_modules/multer-cos/demo/index.js

@@ -0,0 +1,39 @@
+let express= require('express');
+let myMulter = require('./myMulter');
+
+
+let app = express();
+let server = require('http').Server(app);
+
+
+//文件上传服务
+app.post('/upload',  function (req, res, next)  {
+
+    let responseData; //响应的数据
+
+    var upload=myMulter('file',1);
+
+    upload(req, res, function (err) {
+
+           try {
+                 if (err) throw err;
+                 if(req.files.length==0) throw new  Error("不能上传空文件");
+
+                 responseData={msg:"上传成功",code:2000};
+                 responseData.url=req.files[0].url;
+                 res.json(responseData);
+
+
+           }
+           catch (err) {
+                 responseData={msg:"上传失败",code:4000};;
+                 responseData.error=err.message;
+                 res.status(500).json(responseData);
+           }
+     });
+});
+
+
+
+
+server.listen(3000);

package/dist/node_modules/multer-cos/demo/myMulter.js

@@ -0,0 +1,88 @@
+let path=require('path');
+let multer = require('multer');
+let multerCOS = require('multer-COS');
+require( 'dotenv' ).config();
+/**
+ * multer
+ * https://github.com/expressjs/multer/blob/master/doc/README-zh-cn.md
+ * cos
+ * https://cloud.tencent.com/document/product/436/12264#options-object
+ */
+
+
+//定义临时文件
+let dir=path.resolve(__dirname,'./tmp');
+
+//定义mimes-type
+const mimes = {
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.zip':'application/zip',
+    '.txt':'text/plain'
+};
+
+
+const cosConfig={
+    //id和key是必须
+
+    //SecretId: AKIXXXXXXXXXXX,
+    //SecretKey:XXXXXXXXXXXXXX,
+    //Bucket:test-bucket-125XXXXXXXXX
+    //Region=ap-shanghai
+    // 可选参数
+    FileParallelLimit: 3,    // 控制文件上传并发数
+    ChunkParallelLimit: 3,   // 控制单个文件下分片上传并发数
+    ChunkSize: 1024 * 1024,  // 控制分片大小，单位 B
+    domain:'static.dorodoro-lab.com', //cos域名
+    dir:'upload',                     //cos文件路径
+    onProgress:function(progressData){//进度回调函数，回调是一个对象，包含进度信息
+        //console.log(progressData);
+    }
+
+};
+
+
+//定义仓库
+const storage = multerCOS({
+    cos:cosConfig,
+    //Note:如果你传递的是一个函数，你负责创建文件夹，如果你传递的是一个字符串，multer会自动创建 如果什么都不传 系统自己会生成tmp目录
+    destination: function (req, file, cb) {
+        cb(null, dir);
+    },
+    //自己会生成个随机16字母的文件名和后缀
+    filename:'auto'
+});
+
+//测试cos
+//storage.test();
+
+
+//定义过滤器
+const fileFilter =function  (req, file, cb) {
+
+    // 指示是否应接受该文件
+    let test = Object.values(mimes).filter(type=>type===file.mimetype);
+
+    // 接受这个文件，使用`true`，像这样:
+    if(test.length>0){
+        cb(null, true);
+    }else{ // 拒绝这个文件，使用`false`，像这样:
+        cb(new Error('file mimes not allow!'), false);
+    }
+};
+
+//定义限制
+const limits={
+    fileSize:1024 * 1024 * 30
+};
+
+
+module.exports=function(opt) {
+    return  multer({
+        storage: storage,
+        fileFilter:fileFilter,
+        limits: limits,
+    }).array(opt);
+};