z-util-page
Version:
1,536 lines (1,477 loc) • 106 kB
JavaScript
/******/ (function() { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ([
/* 0 */,
/* 1 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ debounce: function() { return /* binding */ debounce; }
/* harmony export */ });
/**
* 将函数处理为防抖函数
* @category 辅助函数
* @example
* ```ts
* let debounced = debounce(function () {
* console.log('身体和心灵，总有一个在路上。');
* return '身体和心灵，总有一个在路上。';
* }, 1000, true);
* debounced.then(function (res) {
* console.log(res);
* });
* debounced();
* debounced.cancel();
* ```
* @param func 待处理函数
* @param wait 函数执行延迟时间
* @param immediatel 是否立刻执行
*/
function debounce(func, wait, immediatel) {
let timeout,
content,
args,
callbacks = [],
res;
/**
* 处理好的防抖函数
* @param this 执行上下文继承自传入函数
* @param args 参数继承自传入函数
*/
const debounced = function (...args) {
content = this;
if (immediatel && !timeout) {
res = func.apply(content, args);
let resolvedRes = res;
callbacks.forEach(function (callback) {
if (callback instanceof Function) resolvedRes = callback(resolvedRes);
});
}
if (timeout) clearTimeout(timeout);
timeout = setTimeout(function () {
func.apply(content, args);
timeout = null;
}, wait);
return res;
};
/**
* 取消防抖函数执行
*/
debounced.cancel = function () {
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
};
/**
* 注册防抖函数执行后的回调
* @param callback 回调函数
* @returns 处理好的防抖函数
*/
debounced.then = function (callback) {
callbacks.push(callback);
return this;
};
return debounced;
}
/***/ }),
/* 2 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ throttle: function() { return /* binding */ throttle; }
/* harmony export */ });
/* harmony import */ var _deepClone_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
const defaultConfig = {
leading: true,
trailing: false
};
/**
* 函数节流
* @category 辅助函数
* @example
* ```ts
* interface throttleOptions {
* // 首次是否执行
* leading: boolean,
* // 结束是否执行
* trailing: boolean
* }
* let throttle = throttle(function(){
* console.log('身体和心灵，总有一个在路上。');
* return '身体和心灵，总有一个在路上。';
* }, 1000, {
* leading: true,
* trailing: true
* });
* throttle();
* throttle.cancel();
* ```
* @param func 待处理函数
* @param wait 函数执行最短间隔时间
* @param option 函数执行配置
*/
function throttle(func, wait, option) {
let options = Object.assign((0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.deepClone)(defaultConfig), option || {});
if (options.leading === false && options.trailing === false) throw 'leading, trailing不能同时为false';
let timeout = null,
args,
content,
res;
/**
* 处理好的节流函数
* @param this 执行上下文继承自传入函数
* @param argList 参数继承自传入函数
*/
const throttled = function (...argList) {
args = argList;
content = this;
if (!timeout) {
timeout = setTimeout(function () {
timeout = null;
if (options.trailing) func.apply(content, args);
}, wait);
if (options.leading) res = func.apply(content, args);
}
return res;
};
/**
* 取消节流函数执行
*/
throttled.cancel = function () {
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
};
return throttled;
}
/***/ }),
/* 3 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ deepClone: function() { return /* binding */ deepClone; },
/* harmony export */ getType: function() { return /* binding */ getType; }
/* harmony export */ });
let cacheMap = new WeakMap();
const typeHandleMap = {
'Object': function (value) {
let cloneTarget = new value.constructor();
forEach(Object.keys(value), function (val, key) {
cloneTarget[val] = realDeepClone(value[val]);
});
return cloneTarget;
},
'Array': function (value) {
let cloneTarget = [];
forEach(value, function (val, key) {
cloneTarget[key] = realDeepClone(value[key]);
});
return cloneTarget;
},
'Set': function (value) {
let cloneTarget = new value.constructor();
value.forEach(function (val) {
cloneTarget.add(realDeepClone(val));
});
return cloneTarget;
},
'Map': function (value) {
let cloneTarget = new value.constructor();
value.forEach(function (val, key) {
cloneTarget.set(realDeepClone(key), realDeepClone(val));
});
return cloneTarget;
},
'Symbol': function (value) {
return Object(Symbol.prototype.valueOf.call(value));
},
'HTMLElement': function (value) {
return value.cloneNode(true);
},
'Error': function (value) {
return new value.constructor(value.message);
}
};
const baseTypeList = ['boolean', 'number', 'string', 'undefined', "function", "symbol", 'Null', "Math", "Json", "Global"];
const simpleTypeList = ["Boolean", "Number", 'String', 'Date', "Regexp"];
/**
* while循环
* @param list 待循环列表
* @param handle 循环行为
*/
function forEach(list, handle) {
let index = -1;
let length = list.length;
while (++index < length) {
handle(list[index], index);
}
}
/**
* 循环深拷贝
* @param value 待克隆值
* @returns 克隆值
*/
function realDeepClone(value) {
let type = typeof value;
if (type === 'object') type = getType(value);
if (value instanceof HTMLElement) type = 'HTMLElement';
if (baseTypeList.includes(type)) return value;else if (simpleTypeList.includes(type)) return new value.constructor(value);
let cloneTarget = cacheMap.get(value);
if (cloneTarget === undefined) {
let handle = typeHandleMap[type];
if (handle) cloneTarget = handle(value);else cloneTarget = value;
cacheMap.set(value, cloneTarget);
}
return cloneTarget;
}
/**
* 获取数据类型
* @category 辅助函数
* @example
* ```ts
* const type = getType('你好');
* type === 'String';
* ```
* @param value 任意值
* @returns 类型字符串, 如'String'、'Map'等
*/
function getType(value) {
try {
return Object.prototype.toString.call(value).match(/\[.+\s(.+)\]/)[1];
} catch (e) {
throw e;
}
}
/**
* 深拷贝
* @category 辅助函数
* @example
* ```ts
* let newValue = deepClone({
* a: '身体和心灵，总有一个在路上。',
* b: {
* c: new Date(),
* d: [1, 3, 4],
* e: Symbol(),
* a: null,
* b: undefined,
* f: {
* a: 1,
* b: true,
* }
* },
* c: document.createElement('div'),
* d: new RegExp(/\d+/ig),
* e: new Error('错误'),
* f: function () {
* console.log('身体和心灵，总有一个在路上。');
* }
* ```
* @param value 待克隆值
* @returns 克隆值
*/
function deepClone(value) {
const result = realDeepClone(value);
cacheMap = new WeakMap();
return result;
}
/***/ }),
/* 4 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ parseUrl: function() { return /* binding */ parseUrl; }
/* harmony export */ });
/**
* 解析URL
* @category 辅助函数
* @example
* ```ts
* const url = 'https://www.baidu.com/s?wd=hello#world'
* const result = parseUrl(url)
* ```
* @param url 统一资源定位符
*/
function parseUrl(url) {
let Url = null;
const param = {};
try {
const temp = new URL(url);
Url = {
hash: temp.hash,
host: temp.host,
hostname: temp.hostname,
href: temp.href,
origin: temp.origin,
password: temp.password,
pathname: temp.pathname,
port: temp.port,
protocol: temp.protocol,
search: temp.search,
username: temp.username,
searchParams: param
};
} catch (error) {
console.log(error);
}
if (Url === null) return null;
const search = Url.search.slice(1);
const paramList = search.split('&').map(item => item.split('='));
paramList.forEach(item => {
param[item[0]] = item[1];
});
return Url;
}
/***/ }),
/* 5 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ generateUUID: function() { return /* binding */ generateUUID; }
/* harmony export */ });
/**
* 生成UUID4
* @category 辅助函数
* @example
* ```ts
* generateUUID();
* generateUUID(12, 32);
* ```
* @param length 生成uuid的总长度，不传递则按照rfc4122标准生成uuid
* @param radix uuid每个字符的基数 1-62
* @returns uuid字符串
*/
function generateUUID(length, radix) {
let chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
let uuid = [];
radix = radix || chars.length;
if (length) {
for (let i = 0; i < length; i++) uuid[i] = chars[0 | Math.random() * radix];
} else {
let r;
uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
uuid[14] = '4';
for (let i = 0; i < 36; i++) {
if (!uuid[i]) {
r = 0 | Math.random() * 16;
uuid[i] = chars[i == 19 ? r & 0x3 | 0x8 : r];
}
}
}
return uuid.join('');
}
/***/ }),
/* 6 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ mergeObject: function() { return /* binding */ mergeObject; }
/* harmony export */ });
/* harmony import */ var _deepClone_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
/**
* 深度合并n个对象值
* @category 辅助函数
* @example
* ```ts
* const a = { a: 1, b: { c: 2 } };
* const b = { b: { d: 3 } };
* const c = { c: 4 };
* mergeObject(a, b, c);
* ```
* @param origin 将多个对象深度合并到该对象
* @param ob 被合并对象
* @param more 其余被合并对象
*/
function mergeObject(origin, ob, ...more) {
do {
origin = merge(origin, ob);
ob = more.pop();
} while (ob);
return origin;
}
function merge(origin, ob) {
if (ob === undefined) return origin;
if ((0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.getType)(origin) !== 'Object' || (0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.getType)(ob) !== 'Object') return origin;
for (const key in ob) {
const oldVal = origin[key];
const newVal = ob[key];
if (oldVal !== newVal && newVal !== undefined) {
if ((0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.getType)(oldVal) !== 'Object') origin[key] = newVal;else merge(oldVal, newVal);
}
}
return origin;
}
/***/ }),
/* 7 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ Http: function() { return /* binding */ Http; }
/* harmony export */ });
/* harmony import */ var _deepClone_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
/* harmony import */ var _FileHelper_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
/* harmony import */ var _message__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11);
/**
* @category HTTTP请求操作辅助类
*/
class Http {
/**
* 构造函数
* @example
* ```ts
* const http = new Http({
* //超时等待时间(ms)
* timeout: 10000,
* //基地址
* baseUrl: 'http://localhost:3000',
* //请求体数据格式
* contentType: 'application/json',
* //响应数据格式
* responseType: 'json'
* });
* ```
* @param options 默认参数
*/
constructor(options = {}) {
/**
* 默认参数
*/
Object.defineProperty(this, "options", {
enumerable: true,
configurable: true,
writable: true,
value: {
timeout: 10000,
baseUrl: '',
contentType: '',
responseType: ''
}
});
/**
* 拦截器
*/
Object.defineProperty(this, "Interceptor", {
enumerable: true,
configurable: true,
writable: true,
value: {
requestArr: [],
responseArr: [],
request(func) {
if (typeof func === 'function') this.requestArr.push(func);
},
response(func) {
if (typeof func === 'function') this.responseArr.push(func);
}
}
});
Object.assign(this.options, options);
}
/**
* XMLHttpRequest异步请求
* @example
* ```ts
* const http = new Http();
* // 拦截器
* http.Interceptor.request((param) => {
* // 请求参数
* console.log(param);
* param.url = 'http://localhost:3000' + param.url;
* })
* http.Interceptor.response((res) => {
* // 请求结果
* console.log(res);
* res.data = res.data + '拦截器修改';
* return res;
* })
*
* // 请求
* const req = http.ajax({
* // 请求地址
* baseUrl: 'http://localhost:3000',
* url: '/api/user',
* // 请求方法
* method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE',
* // 响应数据格式
* type: "arraybuffer" | "blob" | "document" | "json" | "text",
* // 请求头
* headers: {
* 'Content-Type': 'application/json',
* 'Authorization': 'Bearer ' + token
* }
* // 请求体
* data: {
* name: 'jack'
* }
* // 请求参数
* params: {
* name: 'jack'
* }
* // 请求超时时间
* timeout: 10000
* // 请求体数据格式
* contentType: 'application/json',
* // 响应数据类型
* responseType: 'json',
* // 上传文件
* file: {
* file: new Blob([JSON.stringify({a: '身体和心灵，总有一个在路上。'}, null, 2)], {type : 'application/json'})
* }
* }).then((res) => {
* // 请求成功
* }).catch((err) => {
* // 请求失败
* }).finally(() => {
* // 请求完成
* }).progress(() => {
* // 请求进度
* });
*
* // 取消请求
* req.abort();
* ```
* @param param 请求参数
*/
ajax(param) {
const xhr = new XMLHttpRequest();
submit.call(this, xhr, petchParam(param));
return new PromiseHandle(xhr).then(res => {
this.Interceptor.responseArr.forEach(func => {
res = func(res) || res;
});
return res;
});
}
/**
* XMLHttpRequest同步请求，绝大多数情况下只能在work进程内使用。
* @example
* ```ts
* const http = new Http();
* // 请求
* const req = http.ajax({
* // 请求地址
* baseUrl: 'http://localhost:3000',
* url: '/api/user',
* // 请求方法
* method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE',
* // 响应数据格式
* type: "arraybuffer" | "blob" | "document" | "json" | "text",
* // 请求头
* headers: {
* 'Content-Type': 'application/json',
* 'Authorization': 'Bearer ' + token
* }
* // 请求体
* data: {
* name: 'jack'
* }
* // 请求参数
* params: {
* name: 'jack'
* }
* // 请求超时时间
* timeout: 10000
* // 请求体数据格式
* contentType: 'application/json',
* // 响应数据类型
* responseType: 'json',
* // 上传文件
* file: {
* file: new Blob([JSON.stringify({a: '身体和心灵，总有一个在路上。'}, null, 2)], {type : 'application/json'})
* }
* })
* // 请求成功
* console.log(res);
* ```
* @param param 请求参数
*/
ajaxAsync(param) {
const xhr = new XMLHttpRequest();
submit.call(this, xhr, petchParam(param), true);
let res = xhr.response;
this.Interceptor.responseArr.forEach(func => {
res = func(res) || res;
});
return res;
}
}
class PromiseHandle {
constructor(xhr) {
Object.defineProperty(this, "xhr", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "result", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.xhr = xhr;
this.xhr.addEventListener('load', () => {
this.result = this.xhr.response;
});
}
then(callback) {
this.xhr.addEventListener('load', () => {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.Message(this.xhr));
});
return this;
}
catch(callback) {
this.xhr.addEventListener('error', () => {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.Message(this.xhr));
});
return this;
}
finally(callback) {
this.xhr.addEventListener('loadend', () => {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.Message(this.xhr));
});
return this;
}
progress(callback) {
this.xhr.addEventListener('progress', () => {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.Message(this.xhr));
});
return this;
}
downProgress(callback) {
this.xhr.addEventListener('progress', e => {
if (e.lengthComputable) {
var percentComplete = e.loaded / e.total;
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.UploadMessage(this.xhr, '下载中', percentComplete.toFixed(4)));
} else {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.UploadMessage(this.xhr, '无法计算进度', null));
}
});
return this;
}
upProgress(callback) {
this.xhr.upload.addEventListener('progress', e => {
if (e.lengthComputable) {
var percentComplete = e.loaded / e.total;
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.UploadMessage(this.xhr, '上传中', percentComplete.toFixed(4)));
} else {
callback(new _message__WEBPACK_IMPORTED_MODULE_2__.UploadMessage(this.xhr, '无法计算进度', null));
}
});
return this;
}
abort() {
this.xhr.abort();
return this;
}
}
function warp(xhr, param, isInitHeader = true, isAsync = false, isGet = false) {
if (isInitHeader) {
const header = param.header || {};
Object.keys(header).forEach(key => {
if (isGet && key === 'ContentType') return;
xhr.setRequestHeader(upperCase(key), header[key]);
});
if (!isGet && !header.ContentType) xhr.setRequestHeader("Content-Type", this.options.contentType);
}
if (!isAsync) {
xhr.timeout = param.timeout || this.options.timeout;
xhr.responseType = param.responseType || this.options.responseType;
xhr.addEventListener('abort', function () {
console.warn('HTTP请求被中止');
});
xhr.addEventListener('error', function () {
console.warn(xhr.statusText);
});
xhr.addEventListener('timeout', function () {
console.warn('HTTP请求超时');
});
}
}
function submit(xhr, param, isAsync = false) {
this.Interceptor.requestArr.forEach(func => {
param = func(param) || param;
});
let baseUrl = this.options.baseUrl;
if (param.baseUrl !== undefined) {
baseUrl = String(param.baseUrl);
}
let url = baseUrl + (param.url || '');
let paramString = '';
if (param.param && Object.keys(param.param).length !== 0) {
let suffix = url.match(/(?:\?.*)$/);
paramString = suffix === null ? "?" : "&";
Object.keys(param.param || {}).forEach(key => {
paramString += encodeURIComponent(key) + "=" + encodeURIComponent(param.param[key].toString()) + "&";
});
}
if (!param.method || param.method && param.method.toUpperCase() === "GET") {
xhr.open("GET", url + paramString, true);
warp.call(this, xhr, param, true, isAsync, true);
xhr.send(null);
} else {
xhr.open(param.method, url + paramString, true);
let type = this.options.contentType;
if (param.header && param.header.ContentType) type = param.header.ContentType;
const excute = Reflect.get(HttpHandle, type) || Reflect.get(HttpHandle, 'text/plain');
warp.call(this, xhr, param, type !== "multipart/form-data", isAsync, false);
excute.call(this, xhr, param);
}
}
function upperCase(val) {
if (val.length < 1) return val;
let charts = val.split('');
charts[0] = charts[0].toLocaleUpperCase();
return charts.map((c, i) => {
if (c.match(/[A-Z]/) !== null && i !== 0) return `-${c}`;
return c;
}).join('');
}
function petchParam(param) {
if (param.data === undefined) param.data = {};
if (param.header === undefined) param.header = {};
return param;
}
const HttpHandle = {
'application/x-www-form-urlencoded': function (xhr, param) {
let result = [];
Object.keys(param.data || {}).forEach(key => {
let val = param.data[key];
result.push(encodeURIComponent(key) + "=" + encodeURIComponent(val ? val.toString() : val));
});
Promise.resolve().then(() => {
xhr.send(result.join("&"));
});
},
'text/plain': function (xhr, param) {
let result = [];
Object.keys(param.data || {}).forEach(key => {
let val = param.data[key];
result.push(key.replace(/[\s\=\\]/g, "\\$&") + "=" + (val ? val.toString().replace(/[\s\=\\]/g, "\\$&") : val));
});
Promise.resolve().then(() => {
xhr.send(result.join("\r\n"));
});
},
'application/json': function (xhr, param) {
Promise.resolve().then(() => {
xhr.send(JSON.stringify(param.data || {}));
});
},
'multipart/form-data': function (xhr, param) {
const header = param.header || {};
Object.keys(header).forEach(key => {
if (key === "ContentType") return;
xhr.setRequestHeader(upperCase(key), header[key]);
});
if (window.FormData) {
const formData = new FormData();
Object.keys(param.data || {}).forEach(key => {
formData.append(key, param.data[key]);
});
if (param.file) Object.keys(param.file).forEach(key => {
formData.append(key, param.file[key]);
});
Promise.resolve().then(() => {
xhr.send(formData);
});
} else {
let result = [];
Object.keys(param.data || {}).forEach(key => {
let val = param.data[key];
result.push("Content-Disposition: form-data; name=\"" + key + "\"\r\n\r\n" + (val ? val.toString() : val) + "\r\n");
});
let index = 0;
let boundary = "---------------------------" + Date.now().toString(16);
xhr.setRequestHeader("Content-Type", `multipart\/form-data; boundary=` + boundary);
if (param.file && (0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.getType)(param.file) === "Object") {
Object.keys(param.file).forEach(key => {
let file = param.file[key];
let type = (0,_deepClone_index__WEBPACK_IMPORTED_MODULE_0__.getType)(file);
if (type === "File" || type === "Blob") {
index++;
_FileHelper_index__WEBPACK_IMPORTED_MODULE_1__.read(file).load(function (res) {
let name = window.File && file instanceof File ? file.name : key + '.blob';
result.push("Content-Disposition: form-data; name=\"" + key + "\"; filename=\"" + name + "\"\r\nContent-Type: " + (file.type ? file.type : "octet-stream") + "\r\n\r\n" + res.result + "\r\n");
}).loadend(function () {
index--;
if (index === 0) {
let combineResult = "--" + boundary + "\r\n" + result.join("--" + boundary + "\r\n") + "--" + boundary + "--\r\n";
Promise.resolve().then(() => {
xhr.send(combineResult);
});
}
}).start("BinaryString");
}
});
}
if (index === 0) {
Promise.resolve().then(() => {
xhr.send("--" + boundary + "\r\n" + result.join("--" + boundary + "\r\n") + "--" + boundary + "--\r\n");
});
}
}
}
};
/***/ }),
/* 8 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ choose: function() { return /* binding */ choose; },
/* harmony export */ pickDir: function() { return /* binding */ pickDir; },
/* harmony export */ read: function() { return /* binding */ read; },
/* harmony export */ save: function() { return /* binding */ save; },
/* harmony export */ saveFileToDir: function() { return /* binding */ saveFileToDir; }
/* harmony export */ });
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
/* harmony import */ var _helper_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
/* harmony import */ var _debounce_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
/**
* @module FileHelper
* @category 文件操作辅助类
*/
/**
* 文件选择
* @example
* ```ts
* choose({
* accept: [".doc",".docx","application/msword"],
* capture: "user",
* multiple: true
* }).then(files => {
* console.log(files);
* })
* .catch(err => {
* console.error(err);
* });
* ```
* @param options 文件选择配置
* @param options.accept 以逗号为分隔的[唯一文件类型说明符]列表
* @param options.capture 尝试请求使用设备的媒体捕获设备（如：摄像机），而不是请求一个文件输入。camera–照相机；camcorder–摄像机；microphone–录音
* @param options.multiple 是否允许多选
*/
function choose(options = {}) {
return new Promise((resolve, reject) => {
const input = document.createElement('input');
input.setAttribute('type', 'file');
input.setAttribute('accept', (options.accept || []).join(','));
input.setAttribute('capture', options.capture || '');
if (options.multiple) input.setAttribute('multiple', 'true');
input.addEventListener('change', function (e) {
if (input.files) resolve(input.files);
});
(0,_helper_index__WEBPACK_IMPORTED_MODULE_0__.clickElement)(input);
});
}
/**
* H5文件下载方法
* @example
* ```ts
* save(new Blob(['你好世界'], { type: 'text/plain' }), 'test.txt');
* save('https://www.baidu.com/img/flexible/logo/pc/result@2.png', 'baidu.png');
* ```
* @param file 资源链接或者blob对象
* @param saveFileName 保存文件名
*/
function save(file, saveFileName = '') {
let url = '';
if (typeof file === 'string') {
url = file;
} else {
try {
url = URL.createObjectURL(file);
} catch (error) {
console.log(error);
}
}
let alink = document.createElement('a');
alink.href = url;
alink.download = saveFileName || '';
alink.style.display = 'none';
alink.target = "_blank";
document.body.appendChild(alink);
(0,_helper_index__WEBPACK_IMPORTED_MODULE_0__.clickElement)(alink);
document.body.removeChild(alink);
}
class FileReaderDecorate {
constructor(file) {
Object.defineProperty(this, "reader", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "file", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.reader = new FileReader();
this.file = file;
}
//读取操作发生中断时触发
abort(fun) {
this.reader.addEventListener('abort', () => {
fun(this.reader);
});
return this;
}
//读取操作发生错误时触发
error(fun) {
this.reader.addEventListener('error', () => {
fun(this.reader.error);
});
return this;
}
//读取操作完成时触发
load(fun) {
this.reader.addEventListener('load', () => {
fun(this.reader);
});
return this;
}
//读取操作开始时触发
loadstart(fun) {
this.reader.addEventListener('loadstart', () => {
fun(this.reader);
});
return this;
}
//读取操作结束时（要么成功，要么失败）触发
loadend(fun) {
this.reader.addEventListener('loadend', () => {
fun(this.reader.result);
});
return this;
}
//读取操作结束时（要么成功，要么失败）触发。
loadendPromise() {
return new Promise((resolve, reject) => {
this.reader.addEventListener('loadend', () => {
resolve(this.reader.result);
});
this.reader.addEventListener('error', () => {
reject(this.reader.error);
});
});
}
//在读取Blob时触发。
progress(fun) {
this.reader.addEventListener('progress', () => {
fun(this.reader);
});
return this;
}
getStatus() {
return this.reader.readyState;
}
getResult() {
return this.reader.result;
}
start(type) {
try {
Reflect.get(this.reader, "readAs" + type).call(this.reader, this.file);
} catch (error) {
console.error(error);
}
return this;
}
stop() {
this.reader.abort();
return this;
}
}
/**
* 文件读取
* @example
* ```ts
* const reader = read(file)
* .loadend((res) => {
* console.log(res);
* })
* //start方法参数类型："ArrayBuffer" | "BinaryString" | "DataURL" | "Text"
* .start("ArrayBuffer");
*
* //读取操作发生中断时触发
* reader.abort((abo) => {
* console.log(abo);
* })
*
* //读取操作发生错误时触发
* reader.error((err) => {
* console.log(err);
* })
*
* //读取操作完成时触发
* reader.load((res) => {
* console.log(res);
* })
*
* //读取操作开始时触发
* reader.loadstart((res) => {
* console.log(res);
* })
*
* //读取操作结束时（要么成功，要么失败）触发
* reader.loadstart((res) => {
* console.log(res);
* })
*
* //获取读取结果的promise
* const promise = reader.loadendPromise();
*
* //在读取Blob时触发。
* reader.progress((res) => {
* console.log(res);
* })
*
* //获取状态
* const status = reader.getStatus();
*
* //获取结果
* const result = reader.getResult();
*
* //中断读取
* reader.stop();
* ```
* @param file File对象或Blob对象
*/
function read(file) {
return new FileReaderDecorate(file);
}
const DirMap = new Map();
const warnMessage = (0,_debounce_index__WEBPACK_IMPORTED_MODULE_1__.debounce)(err => {
console.warn(err);
}, 100);
/**
* 将文件写入目标文件夹
* @example
* ```ts
* //需要先调用pickDir选择文件夹
* saveFileToDir('key', 'file.txt', ['string', new Blob(['你好世界'], { type: 'text/plain' })]);
* ```
* @param dirKey 文件夹唯一标识，自行定义string，用于后续向同一文件夹写入文件
* @param fileName 文件名
* @param fileContent 二进制文件流或字符串数组
* @param overwrite 是否覆盖同名文件
* @returns { success: boolean, message: string }
*/
function saveFileToDir(dirKey_1, fileName_1, fileContent_1) {
return (0,tslib__WEBPACK_IMPORTED_MODULE_2__.__awaiter)(this, arguments, void 0, function* (dirKey, fileName, fileContent, overwrite = true) {
var _a, fileContent_2, fileContent_2_1;
var _b, e_1, _c, _d;
try {
let dirHandlePromise = DirMap.get(dirKey);
if (!dirHandlePromise) throw new Error("请先选择文件夹");
const dirHandle = yield dirHandlePromise;
// const list = [];
// for await (const key of dirHandle.keys()) {
// list.push(key);
// }
// fileName = getName(list, fileName);
const fileHandle = yield dirHandle.getFileHandle(fileName, {
create: true
});
const writable = yield fileHandle.createWritable();
if (!overwrite) {
const file = yield fileHandle.getFile();
const fileContent = yield read(file).start("ArrayBuffer").loadendPromise();
writable.write(fileContent);
}
try {
for (_a = true, fileContent_2 = (0,tslib__WEBPACK_IMPORTED_MODULE_2__.__asyncValues)(fileContent); fileContent_2_1 = yield fileContent_2.next(), _b = fileContent_2_1.done, !_b; _a = true) {
_d = fileContent_2_1.value;
_a = false;
const item = _d;
yield writable.write(item);
}
} catch (e_1_1) {
e_1 = {
error: e_1_1
};
} finally {
try {
if (!_a && !_b && (_c = fileContent_2.return)) yield _c.call(fileContent_2);
} finally {
if (e_1) throw e_1.error;
}
}
yield writable.close();
return {
success: true,
message: "保存成功"
};
} catch (error) {
if (error.code === 20) {
DirMap.delete(dirKey);
warnMessage(new Error("用户取消选择"));
} else {
console.error(error);
}
return {
success: false,
message: "保存失败"
};
}
});
}
function getName(list, name, index = 1) {
console.log(name);
const res = list.find(item => item === name);
if (res) {
const paths = name.split(".");
const newName = [].concat(paths, [`(${index})`], [paths.pop()]).join('.');
return getName(list, newName, ++index);
} else {
return name;
}
}
/**
* 选择文件夹(与saveFileToDir共用缓存)
* @example
* ```ts
* //选择文件夹，将其与key绑定
* pickDir('key');
* //强制重新选择
* pickDir('key', true);
* ```
* @param dirKey 文件夹唯一标识，自行定义string，用于后续向同一文件夹写入文件
* @param force 是否强制重新选择
* @returns { success: boolean, message: string, data: FileSystemDirectoryHandle | null }
*/
function pickDir(dirKey_1) {
return (0,tslib__WEBPACK_IMPORTED_MODULE_2__.__awaiter)(this, arguments, void 0, function* (dirKey, force = false) {
try {
if (!self.showDirectoryPicker) throw new Error("该浏览器不支持showDirectoryPicker");
let dirHandlePromise = DirMap.get(dirKey);
if (!dirHandlePromise || force) {
dirHandlePromise = self.showDirectoryPicker({
id: dirKey,
mode: 'readwrite'
});
DirMap.set(dirKey, dirHandlePromise);
}
const dirHandle = yield dirHandlePromise;
return {
success: true,
data: dirHandle,
message: "获取成功"
};
} catch (error) {
if (error.code === 20) {
DirMap.delete(dirKey);
warnMessage(new Error("用户取消选择"));
} else {
console.error(error);
}
return {
success: false,
data: null,
message: "获取失败"
};
}
});
}
/***/ }),
/* 9 */
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ __addDisposableResource: function() { return /* binding */ __addDisposableResource; },
/* harmony export */ __assign: function() { return /* binding */ __assign; },
/* harmony export */ __asyncDelegator: function() { return /* binding */ __asyncDelegator; },
/* harmony export */ __asyncGenerator: function() { return /* binding */ __asyncGenerator; },
/* harmony export */ __asyncValues: function() { return /* binding */ __asyncValues; },
/* harmony export */ __await: function() { return /* binding */ __await; },
/* harmony export */ __awaiter: function() { return /* binding */ __awaiter; },
/* harmony export */ __classPrivateFieldGet: function() { return /* binding */ __classPrivateFieldGet; },
/* harmony export */ __classPrivateFieldIn: function() { return /* binding */ __classPrivateFieldIn; },
/* harmony export */ __classPrivateFieldSet: function() { return /* binding */ __classPrivateFieldSet; },
/* harmony export */ __createBinding: function() { return /* binding */ __createBinding; },
/* harmony export */ __decorate: function() { return /* binding */ __decorate; },
/* harmony export */ __disposeResources: function() { return /* binding */ __disposeResources; },
/* harmony export */ __esDecorate: function() { return /* binding */ __esDecorate; },
/* harmony export */ __exportStar: function() { return /* binding */ __exportStar; },
/* harmony export */ __extends: function() { return /* binding */ __extends; },
/* harmony export */ __generator: function() { return /* binding */ __generator; },
/* harmony export */ __importDefault: function() { return /* binding */ __importDefault; },
/* harmony export */ __importStar: function() { return /* binding */ __importStar; },
/* harmony export */ __makeTemplateObject: function() { return /* binding */ __makeTemplateObject; },
/* harmony export */ __metadata: function() { return /* binding */ __metadata; },
/* harmony export */ __param: function() { return /* binding */ __param; },
/* harmony export */ __propKey: function() { return /* binding */ __propKey; },
/* harmony export */ __read: function() { return /* binding */ __read; },
/* harmony export */ __rest: function() { return /* binding */ __rest; },
/* harmony export */ __runInitializers: function() { return /* binding */ __runInitializers; },
/* harmony export */ __setFunctionName: function() { return /* binding */ __setFunctionName; },
/* harmony export */ __spread: function() { return /* binding */ __spread; },
/* harmony export */ __spreadArray: function() { return /* binding */ __spreadArray; },
/* harmony export */ __spreadArrays: function() { return /* binding */ __spreadArrays; },
/* harmony export */ __values: function() { return /* binding */ __values; }
/* harmony export */ });
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
}
return __assign.apply(this, arguments);
}
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0) continue;
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
if (_ = accept(result.get)) descriptor.get = _;
if (_ = accept(result.set)) descriptor.set = _;
if (_ = accept(result.init)) initializers.unshift(_);
}
else if (_ = accept(result)) {
if (kind === "field") initializers.unshift(_);
else descriptor[key] = _;
}
}
if (target) Object.defineProperty(target, contextIn.name, descriptor);
done = true;
};
function __runInitializers(thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
};
function __propKey(x) {
return typeof x === "symbol" ? x : "".concat(x);
};
function __setFunctionName(f, name, prefix) {
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
var __setModuleDefault = Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
function __classPrivateFieldIn(state, receiver) {
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
}
function __addDisposableR