faim
Version:
Element Plus & Element UI isomorphic UI component library, more than Element.
340 lines (339 loc) • 10.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.MB = exports.KB = void 0;
exports.blobLikeToArrayBuffer = blobLikeToArrayBuffer;
exports.blobLikeToBase64 = blobLikeToBase64;
exports.blobToFile = blobToFile;
exports.fileToBlob = fileToBlob;
exports.getAudioMetadata = getAudioMetadata;
exports.getListeners = getListeners;
exports.getOrigin = getOrigin;
exports.getVideoMetadata = getVideoMetadata;
exports.handleNumericalProp = handleNumericalProp;
exports.isBase64WithScheme = isBase64WithScheme;
exports.isEmpty = isEmpty;
exports.isGlobalSlot = isGlobalSlot;
exports.isObject = isObject;
exports.notEmpty = notEmpty;
exports.secondsToHHMMSS = secondsToHHMMSS;
exports.sizeToLabel = sizeToLabel;
exports.toBlobLike = toBlobLike;
exports.toImageTag = toImageTag;
exports.toLocalURL = toLocalURL;
exports.unwrap = unwrap;
var _lodashEs = require("lodash-es");
var _isBase = _interopRequireDefault(require("validator/es/lib/isBase64"));
var _isURL = _interopRequireDefault(require("validator/es/lib/isURL"));
var _vueDemi = require("vue-demi");
var _vueGlobalConfig = require("vue-global-config");
var _MessageBox = _interopRequireDefault(require("./components/MessageBox"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const MB = exports.MB = 1024 ** 2;
const KB = exports.KB = 1024;
function getListeners(globalListeners) {
if (_vueDemi.isVue3) {
return {};
}
for (const k in globalListeners) {
globalListeners[k] = globalListeners[k].bind(this);
}
return (0, _vueGlobalConfig.conclude)([(0, _vueGlobalConfig.getLocalListeners)(this.$listeners)], {
default: globalListeners,
mergeFunction: (localEventListener, globalEventListener) => (...args) => {
localEventListener(...args);
globalEventListener(...args);
}
});
}
function isGlobalSlot(slot) {
return typeof slot === "function" && slot.name.startsWith("#");
}
function isEmpty(value) {
return {
object: () => value === null || Array.isArray(value) && value.length === 0 || (0, _lodashEs.isPlainObject)(value) && Object.getOwnPropertyNames(value).length === 0,
number: () => Number.isNaN(value),
string: () => value === "",
undefined: () => true,
boolean: () => value === false,
symbol: () => false,
bigint: () => false,
function: () => true
}[typeof value]();
}
function notEmpty(value) {
return !isEmpty(value);
}
function isObject(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function isBase64WithScheme(str, mediaType) {
if (!str || typeof str !== "string") {
return false;
}
if (mediaType && !str.startsWith(`data:${mediaType}`)) {
return false;
} else {
const base64WithoutScheme = str.split(",")[1];
return base64WithoutScheme ? (0, _isBase.default)(base64WithoutScheme) : false;
}
}
function blobLikeToBase64(binary) {
return new Promise((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onerror = e => {
reject(e);
};
fileReader.onload = e => {
resolve(e.target?.result);
};
fileReader.readAsDataURL(binary);
});
}
async function toBlobLike(source) {
if (typeof source === "string") {
if ((0, _isURL.default)(source) || isBase64WithScheme(source, "image/") || source.startsWith("blob:")) {
return await (await fetch(source)).blob();
}
return Promise.reject(new Error("Error parsing image"));
}
return Promise.resolve(source);
}
async function toLocalURL(source) {
if (typeof source === "string") {
if (source.startsWith("blob:")) {
return Promise.resolve(source);
}
if ((0, _isURL.default)(source)) {
return blobLikeToBase64(await toBlobLike(source));
}
if (isBase64WithScheme(source, "image/")) {
return Promise.resolve(source);
}
return Promise.reject(new Error("Error parsing image"));
}
return blobLikeToBase64(source);
}
async function toImageTag(src) {
return new Promise((resolve, reject) => {
const image = new Image();
image.onerror = e => {
reject(e);
};
image.onload = () => {
resolve(image);
};
image.src = src;
});
}
function unwrap(value, srcAt) {
if (!(value && srcAt)) {
return value;
}
switch (typeof srcAt) {
case "string":
return (0, _lodashEs.at)(value, srcAt)[0];
case "function":
return srcAt(value);
case "symbol":
if ((0, _lodashEs.isPlainObject)(value)) {
return value[srcAt];
}
}
}
const isPositiveNumber = number => typeof number === "number" && !Number.isNaN(number) && number > 0;
function handleNumericalProp({
config,
labelTip,
createTitleTextOfNotMatched,
createTitleTextOfMinExceeded,
createTitleTextOfMaxExceeded,
withUnit = value => value.toLocaleString(),
getValue = value => value
}) {
const value = (0, _vueGlobalConfig.conclude)(config, {
validator: value2 => {
if ((0, _lodashEs.isPlainObject)(value2)) {
const min2 = getValue(value2.min);
const max2 = getValue(value2.max);
const minIsValid = isPositiveNumber(min2);
const maxIsValid = isPositiveNumber(max2);
return minIsValid && maxIsValid && min2 < max2 || minIsValid && max2 === void 0 || min2 === void 0 && maxIsValid || min2 === void 0 && max2 === void 0;
} else if (Array.isArray(value2)) {
for (const v of value2) {
if (!isPositiveNumber(getValue(v))) {
return false;
}
}
return value2.length > 0;
} else {
return isPositiveNumber(getValue(value2));
}
}
});
let tip;
let titleTextOfNotMatched;
let titleTextOfMinExceeded;
let titleTextOfMaxExceeded;
let min;
let minLabel;
let max;
let maxLabel;
let options;
let optionsLabel;
let target;
let targetLabel;
if ((0, _lodashEs.isPlainObject)(value)) {
min = getValue(value.min);
max = getValue(value.max);
if (min && max) {
minLabel = withUnit(value.min);
maxLabel = withUnit(value.max);
tip = `${labelTip} ${minLabel} ~ ${maxLabel}`;
titleTextOfMinExceeded = createTitleTextOfMinExceeded(minLabel);
titleTextOfMaxExceeded = createTitleTextOfMaxExceeded(maxLabel);
} else if (max) {
maxLabel = withUnit(value.max);
tip = `${labelTip} \u2264 ${maxLabel}`;
titleTextOfMaxExceeded = createTitleTextOfMaxExceeded(maxLabel);
} else if (min) {
minLabel = withUnit(value.min);
tip = `${labelTip} \u2265 ${minLabel}`;
titleTextOfMinExceeded = createTitleTextOfMinExceeded(minLabel);
}
} else if (Array.isArray(value)) {
options = value.map(getValue);
optionsLabel = value.map(withUnit).join(" / ");
tip = `${labelTip} ${optionsLabel}`;
titleTextOfNotMatched = createTitleTextOfNotMatched(optionsLabel);
} else if (value !== void 0) {
target = getValue(value);
targetLabel = withUnit(value);
tip = `${labelTip} ${targetLabel}`;
titleTextOfNotMatched = createTitleTextOfNotMatched(targetLabel);
}
function validate(v) {
let titleText;
if (max && v > max) {
titleText = titleTextOfMaxExceeded;
} else if (min && v < min) {
titleText = titleTextOfMinExceeded;
} else if (options && !options.includes(v)) {
titleText = titleTextOfNotMatched;
} else if (target && v !== target) {
titleText = titleTextOfNotMatched;
}
if (titleText) {
_MessageBox.default.warning({
titleText,
timer: 5e3
});
}
return !titleText;
}
return {
tip,
validate,
min,
minLabel,
max,
maxLabel,
options,
optionsLabel,
target,
targetLabel
};
}
function getVideoMetadata(source) {
const url = source instanceof Blob ? URL.createObjectURL(source) : source;
return new Promise((resolve, reject) => {
const video = document.createElement("video");
video.addEventListener("error", e => {
reject(e);
});
video.addEventListener("loadedmetadata", () => {
if (source instanceof Blob) {
URL.revokeObjectURL(url);
}
resolve(video);
});
video.src = url;
});
}
function getAudioMetadata(source) {
const url = source instanceof Blob ? URL.createObjectURL(source) : source;
return new Promise((resolve, reject) => {
const audio = document.createElement("audio");
audio.addEventListener("error", e => {
reject(e);
});
audio.addEventListener("loadedmetadata", () => {
if (source instanceof Blob) {
URL.revokeObjectURL(url);
}
resolve(audio);
});
audio.src = url;
});
}
function secondsToHHMMSS(seconds) {
let Seconds = Number.parseInt(String(seconds), 10);
const Hours = Math.floor(Seconds / 3600);
const Minutes = Math.floor(Seconds / 60) % 60;
Seconds %= 60;
return [Hours, Minutes, Seconds].map(v => v < 10 ? `0${v}` : v).filter((v, i) => v !== "00" || i > 0).join(":");
}
function sizeToLabel(bytes) {
if (bytes >= MB) {
return `${Number.parseFloat((bytes / MB).toFixed(1))}M`;
} else if (bytes >= KB) {
return `${(bytes / KB).toFixed(0)}K`;
} else {
return `${bytes.toFixed(0)}B`;
}
}
function getOrigin(url) {
if (url.startsWith("//")) {
return `//${new URL(window.location.protocol + url).host}`;
} else if (!url.startsWith("http")) {
return new URL(`${window.location.protocol}//${url}`).host;
}
const urlObj = new URL(url);
return `${urlObj.protocol}//${urlObj.host}`;
}
async function fileToBlob(file) {
return file instanceof File ? new Promise((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onerror = e => {
reject(e);
};
fileReader.onload = e => {
resolve(e.target?.result ? new Blob([e.target.result], {
type: file.type
}) : null);
};
fileReader.readAsArrayBuffer(file);
}) : Promise.resolve(file);
}
async function blobLikeToArrayBuffer(blobLike) {
return new Promise((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onerror = e => {
reject(e);
};
fileReader.onload = e => {
resolve(e.target?.result);
};
fileReader.readAsArrayBuffer(blobLike);
});
}
function blobToFile(blob, fileName, fileType) {
if (!fileName) {
const extension = blob.type.split("/")[1];
fileName = `${(/* @__PURE__ */new Date()).getTime().toString()}.${extension}`;
}
return blob instanceof File ? blob : new File([blob], fileName, {
type: fileType || blob.type
});
}