general-assistant
Version:
General Assistant components
338 lines (337 loc) • 12 kB
JavaScript
import React from 'react';
import { toast } from 'datastellar-chatui';
import { defaultsDeep, toLower, toUpper } from 'lodash';
import html2canvas from 'html2canvas';
export function RandomString(length = 9) {
const characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
let result = '';
for (let i = 0; i < length; i++) {
const randomIndex = Math.floor(Math.random() * characters.length);
result += characters.charAt(randomIndex);
}
return result;
}
export function isJSON(str) {
if (typeof str === 'string') {
try {
JSON.parse(str);
return true;
}
catch (e) {
return false;
}
}
}
export async function ASYNC_loadCompFromRemote(obj) {
const loadRemoteComponent = async (url) => {
const script = await fetch(url).then(res => res.text());
const module = { exports: {} };
const exports = {};
const require = (id) => {
if (id === 'react') {
return React;
}
};
const func = new Function('module', 'exports', 'require', script);
func(module, exports, require);
return module.exports;
};
let _obj = obj;
for (const key in _obj) {
const element = _obj[key];
if (typeof element === 'string') {
if (element.search(/^http/) === 0) {
try {
const _mymodule = (await loadRemoteComponent(element));
_obj[key] = _mymodule.default;
}
catch (error) {
_obj[key] = null;
console.log('loadCompFromRemote ? ', error);
}
}
}
}
return _obj;
}
export function SYNC_loadCompFromRemote({ cardId, cardFileUrl }) {
return new Promise(function (resolve, reject) {
if (cardFileUrl.search(/^http/) === 0) {
fetch(cardFileUrl).then(res => res.text()).then(script => {
const module = { exports: {} };
const exports = {};
const require = (id) => {
if (id === 'react') {
return React;
}
};
const func = new Function('module', 'exports', 'require', script);
func(module, exports, require);
if (module.exports.default) {
resolve({ [cardId]: module.exports.default });
}
else {
reject({ [cardId]: null });
}
}).catch(error => {
reject({ [cardId]: null });
});
}
else {
reject({ [cardId]: null });
}
});
}
export function copyToClipboard(text) {
return new Promise(function (resolve, reject) {
if (navigator.clipboard) {
navigator.clipboard.writeText(text).then(function () {
resolve(true);
}, function (err) {
resolve(false);
});
}
else if (document.execCommand('copy')) {
if (navigator.userAgent.match(/(iPhone|iPod|iPad);?/i)) {
const range = document.createRange();
range.selectNode(text);
const selection = window.getSelection();
if (selection.rangeCount > 0)
selection.removeAllRanges();
selection.addRange(range);
document.execCommand('copy') ? resolve(true) : resolve(false);
}
else {
var input = document.createElement('input');
input.setAttribute('readonly', 'readonly');
input.setAttribute('value', text);
document.body.appendChild(input);
input.setSelectionRange(0, 9999);
input.select();
document.execCommand('copy') ? resolve(true) : resolve(false);
document.body.removeChild(input);
}
}
else {
resolve(false);
}
});
}
export function sendRequestWithConfig(args) {
const { commonOpt, parameter, isFecth, controller: argController, onResponse, onCatch, onFinally } = args;
const { url, ResponseFormat, CatchFormat } = parameter;
const controller = argController || new AbortController();
const time = parameter.timeout || commonOpt.timeout || 5000;
const timer = setTimeout(() => {
controller.abort();
}, time);
let _paramCopy = Object.assign({}, parameter);
delete _paramCopy.url;
delete _paramCopy.ResponseFormat;
delete _paramCopy.CatchFormat;
delete _paramCopy.timeout;
let _optCopy = Object.assign({}, commonOpt);
delete _optCopy.timeout;
const _reqOpt = defaultsDeep(_paramCopy, _optCopy);
if (url === undefined)
return onCatch('Parameter "url" is undefined');
fetch(url, { ..._reqOpt, signal: controller.signal })
.then(async (res) => {
clearTimeout(timer);
if (isFecth && res.body && typeof res.body.getReader === 'function') {
const reader = res.body.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) {
onFinally();
break;
}
let textValue = new TextDecoder().decode(value);
let _formatT = textValue;
if (typeof ResponseFormat === 'function') {
try {
_formatT = ResponseFormat(textValue);
}
catch (errorT) {
throw errorT;
}
}
onResponse(_formatT);
}
}
else {
const decodeValue = await res.json();
let _formatD = decodeValue;
if (typeof ResponseFormat === 'function') {
try {
_formatD = ResponseFormat(decodeValue);
}
catch (errorD) {
throw errorD;
}
}
onResponse(_formatD);
}
})
.catch(e => {
clearTimeout(timer);
let _formatCat = e.message;
if (typeof CatchFormat === 'function') {
try {
_formatCat = CatchFormat(e);
}
catch (errorC) {
onCatch(errorC);
return;
}
}
onCatch(_formatCat);
})
.finally(() => onFinally());
}
export function getMedia() {
return new Promise((resolve, reject) => {
const myNavigator = navigator;
try {
if (myNavigator) {
if (myNavigator.mediaDevices && myNavigator.mediaDevices.getUserMedia) {
myNavigator.mediaDevices.getUserMedia({ audio: true })
.then((stream) => resolve(stream))
.catch((err) => resolve(err.message));
}
else if (myNavigator.oGetUserMedia) {
myNavigator.oGetUserMedia({ audio: true })
.then((stream) => resolve(stream))
.catch((err) => resolve(err.message));
}
else if (myNavigator.msGetUserMedia) {
myNavigator.msGetUserMedia({ audio: true })
.then((stream) => resolve(stream))
.catch((err) => resolve(err.message));
}
else if (myNavigator.webkitGetUserMedia) {
myNavigator.webkitGetUserMedia({ audio: true })
.then((stream) => resolve(stream))
.catch((err) => resolve(err.message));
}
else if (myNavigator.mozGetUserMedia) {
myNavigator.mozGetUserMedia({ audio: true })
.then((stream) => resolve(stream))
.catch((err) => resolve(err.message));
}
else {
resolve('Not support');
}
}
else {
resolve('Not support');
}
}
catch (error) {
resolve(error.message);
}
});
}
function getMimeType(mtype) {
switch (mtype) {
case 'mp3':
return 'audio/mpeg';
case 'mpeg':
return 'audio/mpeg';
case 'mpga':
return 'audio/mpeg';
case 'mp4':
return 'video/mp4';
case 'm4a':
return 'audio/mp4a';
case 'wav':
return 'audio/wav';
case 'webm':
return 'video/webm';
default:
throw new Error('Unsupported media type');
}
}
export function blobToFile(mtype, chunks) {
return new Promise((resolve, reject) => {
try {
const audioBlob = new Blob(chunks, { type: getMimeType(mtype) });
console.log('audioBlob', audioBlob);
const _audio_id = new Date().getTime();
const file = new File([audioBlob], _audio_id.toString(), {
lastModified: _audio_id,
type: audioBlob.type
});
const formData = new FormData();
formData.append('file', file);
resolve(formData);
}
catch (error) {
reject('不支持的类型：' + mtype);
}
});
}
export function showToast(text) {
toast.show(text);
}
export const FileIcon = {
'code': ['js', 'ts', 'tsx', 'jsx', 'css', 'less', 'sass', 'html', 'java', 'class', 'mapper', 'xml', 'json'],
'wendang': ['doc', 'docx', 'md', 'txt'],
'baobiao': ['xls', 'xlsx', 'ppt', 'pptx'],
'yasuo': ['zip', 'rar', 'gz', 'z', 'jar', 'arj'],
'img': ['png', 'jpg', 'jpeg', 'bmp', 'gif', 'psd', 'svg', 'webp'],
'yingyin': ['mp4', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'web', 'm4v', '3gp', 'mpeg', 'mpg', 'rmvb',]
};
export function getFileName(_u) {
if (!_u.toString().startsWith('http'))
return _u;
const _name = _u.toString().match(/([^/]+\.\w{3,4})$/);
return _name !== null ? _name[0] : '网络文件';
}
export function getFileTypeIcon(_t, _n) {
let _icon = 'file';
let _color = 'text-theme-shal-3';
const _suf = _n.toString().match(/.\w{3,4}$/);
if (_suf !== null) {
const _lowcase = toLower(_suf[0]).replace(/^./, '');
if (FileIcon.wendang.includes(_lowcase)) {
_color = 'text-[#b71c1c]';
}
if (FileIcon.baobiao.includes(_lowcase)) {
_color = 'text-[#ff9800]';
}
if (FileIcon.yingyin.includes(_lowcase)) {
_color = 'text-[#43a047]';
}
if (FileIcon.img.includes(_lowcase)) {
_color = 'text-[#1e88e5]';
}
if (FileIcon.code.includes(_lowcase)) {
_color = 'text-[#673ab7]';
}
}
if (_color === 'text-theme-shal-3' && _t === 'url') {
_icon = 'upload';
_color = 'text-[#009688]';
}
return { suf: _suf !== null ? toUpper(_suf[0].replace(/^./, '')) : '', color: _color, icon: _icon };
}
export function getFileGeneralSize(_bytes) {
const units = ['B', 'KB', 'MB', 'GB', 'TB'];
const unitIndex = Math.floor(Math.log2(_bytes) / 10);
const unitMother = (1024 ** unitIndex).toFixed(2);
return `${_bytes / Number(unitMother)}${units[unitIndex]}`;
}
export function getSnapshot(node, options) {
return new Promise(async (resolve, reject) => {
let canvas = null;
try {
canvas = await html2canvas(node, options);
canvas = canvas.toDataURL("image/png");
}
catch (error) {
reject(error.toString());
}
resolve(canvas);
});
}