tav-ui
Version:
636 lines (629 loc) • 26.9 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var antDesignVue = require('ant-design-vue');
var AsyncValidator = require('async-validator');
require('../../../../locales/index2.js');
var useMessage = require('../../../../hooks/web/useMessage2.js');
var useGlobalConfig = require('../../../../hooks/global/useGlobalConfig2.js');
var index = require('../components/FileActionUploadLink/index4.js');
var index$1 = require('../components/FileActionUpload/index3.js');
require('../hooks/index2.js');
require('../utils/index2.js');
var consts = require('../consts2.js');
var index$2 = require('../components/FileVersion/index3.js');
var index$4 = require('../components/FileLog/index4.js');
var index$3 = require('../components/FilePreview/index3.js');
var types = require('./types2.js');
require('./hooks/index2.js');
var ListItem = require('./components/ListItem2.js');
var pluginVue_exportHelper = require('../../../../../_virtual/plugin-vue_export-helper.js');
var setup$1 = require('../utils/setup2.js');
var versionCaches = require('../hooks/version-caches2.js');
var useProps = require('../hooks/use-props2.js');
var useDisable = require('../hooks/use-disable2.js');
var useLoading = require('../hooks/use-loading2.js');
var useRequest = require('../hooks/use-request2.js');
var useHandleDataSource = require('./hooks/use-handle-data-source2.js');
var useMode = require('./hooks/use-mode2.js');
var useCardActions = require('./hooks/use-card-actions2.js');
var useDataSource = require('./hooks/use-data-source2.js');
var extend = require('../utils/extend2.js');
var download = require('../utils/download2.js');
var useActions = require('./hooks/use-actions2.js');
var useItems = require('./hooks/use-items2.js');
var visibile = require('../utils/visibile2.js');
var transfer = require('../../../../locales/transfer2.js');
var useRules = require('./hooks/use-rules2.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var AsyncValidator__default = /*#__PURE__*/_interopDefaultLegacy(AsyncValidator);
const _hoisted_1 = ["id"];
const _hoisted_2 = ["innerHTML"];
const __default__ = {
name: "TaFileCard",
inheritAttrs: false
};
function setup(__props, { expose, emit: emits }) {
const props = __props;
const DEFAULT_FILECARD_ID = setup$1.createId(consts.DEFAULT_FILECARD_CLASSNAME);
const { createMessage } = useMessage.useMessage();
const headerExtraElRef = vue.ref();
const slots = vue.useSlots();
const attrs = vue.useAttrs();
const FileActionUploadForActionUpdateBtnRef = vue.ref();
const VersionCachesController = new versionCaches.VersionCaches();
const globalConfigProps = useProps.useGlobalConfigProps();
const mergedProps = useProps.useMergedProps(globalConfigProps, props, "TaFileCard", {
...consts.DEFAULT_APIPARAMS
});
const fileApiParams = vue.ref(props.apiParams);
vue.watch(() => JSON.stringify(props.apiParams), async (curapiParams, preapiParams) => {
if (curapiParams !== preapiParams) {
fileApiParams.value = props.apiParams;
}
});
const fileActionUploadRef = vue.ref();
const fileActionUploadProps = vue.computed(() => {
return {
...props.fileActionUpload,
mode: props.mode,
apiParams: {
appId: fileApiParams.value.appId,
moduleCode: fileApiParams.value.moduleCode,
typeCode: fileApiParams.value.typeCode,
businessId: fileApiParams.value.businessId,
businessKey: fileApiParams.value.businessKey,
businessParamsJson: fileApiParams.value.businessParamsJson ?? consts.DEFAULT_APIPARAMS.businessParamsJson,
fileName: fileApiParams.value.fileName,
...props.fileActionUpload?.apiParams ?? {}
},
buttonType: "primary",
buttonSize: "small",
buttonIcon: false
};
});
const fileActionUploadLinkRef = vue.ref();
const fileActionUploadLinkProps = vue.computed(() => {
return {
...props.fileActionUploadLink,
mode: props.mode,
apiParams: {
appId: fileApiParams.value.appId,
moduleCode: fileApiParams.value.moduleCode,
typeCode: fileApiParams.value.typeCode,
businessId: fileApiParams.value.businessId,
businessKey: fileApiParams.value.businessKey,
businessParamsJson: fileApiParams.value.businessParamsJson ?? consts.DEFAULT_APIPARAMS.businessParamsJson,
...props.fileActionUploadLink?.apiParams ?? {}
},
getFormContainer: () => headerExtraElRef.value,
buttonSize: "small",
buttonIcon: false
};
});
const _loading = vue.ref(mergedProps.value.loading);
const loading = vue.computed({
get() {
return _loading;
},
set(newLoading) {
_loading.value = newLoading.value;
}
});
const { setDisable } = useDisable.useDisable();
const { setLoading } = useLoading.useLoading();
const {
result: ApiResult,
error: ApiError,
handleApi
} = useRequest.useRequest({
setDisable,
setLoading,
loading
});
const hasEmptyDataSource = vue.computed(() => {
return mergedProps.value.__dataSourceFromCards || !mergedProps.value.dataSource;
});
const {
apiActions: { apiQueryFileOptions },
dataSource,
handleDataSource,
setDataSource,
handleApiDataSource
} = useHandleDataSource.useHandleDataSource({
mergedProps,
emits,
VersionCachesController,
ApiResult,
ApiError,
handleApi
});
const {
apiActions: { rowEditorApiOptions, historyApiOptions, deleteApiOptions },
dataActions: { reloadRows, editRow, updateRow, deleteRow }
} = useMode.useMode({
mergedProps,
emits,
VersionCachesController,
handleApiDataSource,
hasEmptyDataSource
});
const { cardCreateRows, cardReadRows, cardUpdateRows, cardDeleteRows } = useCardActions.useCardActions({
mergedProps,
dataSource,
setDataSource,
loading
});
useDataSource.useDataSource({
mergedProps,
emits,
VersionCachesController,
dataSource
});
async function beforeReadFileCaches(row) {
loading.value.value = true;
if (!VersionCachesController.isCachesEmpty() && VersionCachesController.readFileCaches(row.actualId)) {
loading.value.value = false;
if (row.version === VersionCachesController.readFileCaches(row.actualId).length)
return extend.extendCurrentRowActionsAuth(row, VersionCachesController.readFileCaches(row.actualId));
}
const options = historyApiOptions(mergedProps.value.apiParams, row);
if (!options) {
loading.value.value = false;
return [];
}
const { success, data } = await mergedProps.value.apiQueryFileHistory(options.apiParams);
if (success === true && data) {
loading.value.value = false;
const result = [
...VersionCachesController.createFileCaches(row, extend.extendCurrentRowActionsAuth(row, data)) ?? []
];
const dataSource2 = JSON.parse(JSON.stringify(await cardReadRows()));
if (mergedProps.value.mode === "update" || mergedProps.value.mode === "updateInstantly") {
emits("actualidsChange", VersionCachesController.getCaches());
} else {
emits("actualidsChange", dataSource2.map((file) => file.actualId));
}
return result;
}
loading.value.value = false;
return [];
}
async function refreshCardDataApiAction(params) {
await reloadRows(params);
}
async function handleRowEditClick(changeEventPayload, row) {
if (row.hyperlink && changeEventPayload.name === row.name && changeEventPayload.address === row.address || !row.hyperlink && changeEventPayload.name === row.name) {
return;
}
async function editRowApiAction() {
const options = rowEditorApiOptions(mergedProps.value.apiParams, changeEventPayload);
if (!options)
return;
await handleApi(options);
}
loading.value.value = true;
await editRow(changeEventPayload, row, cardUpdateRows, editRowApiAction, hasEmptyDataSource, refreshCardDataApiAction);
loading.value.value = false;
emits("rowEdit", row);
}
const fileVersionModalVisible = vue.ref(false);
const fileVersionFile = vue.ref();
const fileVersionDataSource = vue.ref();
async function hanldeVersionClick(row) {
fileVersionFile.value = row;
if (mergedProps.value.mode === "update" || mergedProps.value.mode === "updateInstantly") {
const fileCaches = await beforeReadFileCaches(row);
fileVersionDataSource.value = fileCaches;
} else {
fileVersionDataSource.value = [row];
}
fileVersionModalVisible.value = true;
}
const filePreviewModalVisible = vue.ref(false);
const filePreviewFile = vue.ref();
function handleViewBtnClick(row) {
filePreviewModalVisible.value = true;
filePreviewFile.value = row;
}
const actionUpdateClickRow = vue.ref();
async function handleUpdateBtnClick(row) {
if (mergedProps.value.mode === "update" || mergedProps.value.mode === "updateInstantly") {
await beforeReadFileCaches(row);
}
actionUpdateClickRow.value = { ...row, cache: VersionCachesController["caches"][row.actualId] };
FileActionUploadForActionUpdateBtnRef.value?.openFilePicker?.();
emits("rowUpdate", row);
}
async function handleFileActionUploadForActionUpdateBtnChange(...args) {
const [files] = args;
loading.value.value = true;
await updateRow(files[0], actionUpdateClickRow.value, cardUpdateRows, hasEmptyDataSource, refreshCardDataApiAction);
loading.value.value = false;
actionUpdateClickRow.value = void 0;
}
async function handleDownloadWatermarkBtnClick(row) {
if (!mergedProps.value.apiDownloadWaterMarkerFile) {
console.warn("[tavui TaFileCard] apiDownloadWaterMarkerFile is undefined");
return;
}
loading.value.value = true;
try {
await download.fileSingleDownload({
file: row,
api: mergedProps.value.apiDownloadWaterMarkerFile
});
} catch (error) {
console.warn("[tavui TaFileCard] apiDownloadWaterMarkerFile has error", error);
} finally {
loading.value.value = false;
}
}
async function handleDownloadBtnClick(row) {
if (!mergedProps.value.apiDownloadFile) {
console.warn("[tavui TaFileCard] apiDownloadFile is undefined");
return;
}
loading.value.value = true;
try {
await download.fileSingleDownload({
file: row,
api: mergedProps.value.apiDownloadFile
});
} catch (error) {
console.warn("[tavui TaFileCard] apiDownloadFile has error", error);
} finally {
loading.value.value = false;
}
}
async function handleDeleteBtnClick(row) {
async function deleteRowApiAction() {
const options = deleteApiOptions(mergedProps.value.apiParams, row);
if (!options)
return;
await handleApi(options);
}
loading.value.value = true;
await deleteRow(row, cardDeleteRows, deleteRowApiAction, hasEmptyDataSource, refreshCardDataApiAction, validate);
loading.value.value = false;
emits("rowDelete", row);
}
const fileLogModalVisible = vue.ref(false);
const fileLogFile = vue.ref();
async function handleLogBtnClick(row) {
fileLogFile.value = row;
fileLogModalVisible.value = true;
}
const globalConfigUserInfo = useGlobalConfig.useGlobalConfig("userInfo");
const actions = useActions.useActions({
mergedProps,
handleViewBtnClick,
handleUpdateBtnClick,
handleDownloadWatermarkBtnClick,
handleDownloadBtnClick,
handleDeleteBtnClick,
handleLogBtnClick,
globalConfigUserInfo,
VersionCachesController
});
const items = useItems.useItems({
mergedProps,
actions,
handleRowEditClick,
hanldeVersionClick
});
const editConfig = vue.computed(() => mergedProps.value.enabledRowEdit ? {
trigger: "click",
mode: "cell",
autoClear: true,
beforeEditMethod: ({ row: _row }) => {
const row = _row;
const isEdit = visibile.isFullNameColEdit(mergedProps.value.enabledRowEdit, mergedProps.value.mode, mergedProps.value.enabledOwner, globalConfigUserInfo.value, row.owner);
if (!isEdit) {
createMessage.warn(`${transfer.tavI18n("Tav.common.notAuthorised")}`);
}
return isEdit;
}
} : void 0);
const rules = useRules.useRules({
mergedProps
});
const isRequired = vue.computed(() => !!rules.value.find((rule) => rule.required));
function getRuleByTriggerName(trigger) {
return (vue.toRaw(rules).value ?? []).filter((rule) => {
if (!rule.trigger || trigger === "")
return true;
if (Array.isArray(rule.trigger)) {
return rule.trigger.indexOf(trigger) > -1;
} else {
return rule.trigger === trigger;
}
}).map((rule) => ({ ...rule }));
}
const validateMessage = vue.ref("");
async function validate(trigger, callback) {
const _rules = getRuleByTriggerName(trigger);
if (_rules.length === 0) {
callback?.(true);
return true;
}
if (_rules && _rules.length > 0) {
_rules.forEach((rule) => {
Reflect.deleteProperty(rule, "trigger");
Reflect.deleteProperty(rule, "key");
});
}
const validator = new AsyncValidator__default["default"]({ [mergedProps.value.value]: _rules });
return validator.validate({ [mergedProps.value.value]: dataSource.value }, { firstFields: true }).then(() => {
validateMessage.value = "";
callback?.(true);
return true;
}).catch((err) => {
const { fields, errors } = err;
if (mergedProps.value.autoValidate) {
validateMessage.value = errors ? errors[0].message ?? "" : "";
}
callback?.(false, fields);
return callback ? false : Promise.reject(fields);
});
}
async function retriggerHandleDataSource() {
if (mergedProps.value.dataSource || mergedProps.value.immediate) {
await handleDataSource();
}
}
function handleFileActionUploadChangeValidateSuccessChange(...args) {
emits("fileActionUpload:validateSuccessChange", ...args);
}
function handleFileActionUploadChangeValidateFailureChange(...args) {
emits("fileActionUpload:validateFailureChange", ...args);
}
async function handleFileActionUploadChange(...args) {
emits("fileActionUpload:uploadedChange", ...args);
const [files] = args;
if (mergedProps.value.mode === "updateInstantly" && hasEmptyDataSource.value) {
await refreshCardDataApiAction({ typeCodes: [mergedProps.value.value] });
} else {
setDataSource([...files, ...dataSource.value]);
}
mergedProps.value.autoValidate && await validate("change", (...args2) => args2[1] && console.warn("[tavui TaFileCard] delete has error: ", args2[1]));
}
function handleFileActionUploadLinkChangeValidateSuccessChange(...args) {
emits("fileActionUploadLink:validateSuccessChange", ...args);
}
function handleFileActionUploadLinkChangeValidateFailureChange(...args) {
emits("fileActionUploadLink:validateFailureChange", ...args);
}
async function handleFileActionUploadLinkChange(...args) {
emits("fileActionUploadLink:uploadedChange", ...args);
const [files] = args;
if (mergedProps.value.mode === "updateInstantly" && hasEmptyDataSource.value) {
await refreshCardDataApiAction({ typeCodes: [mergedProps.value.value] });
} else {
setDataSource([...files, ...dataSource.value]);
}
mergedProps.value.autoValidate && await validate("change", (...args2) => args2[1] && console.warn("[tavui TaFileCard] delete has error: ", args2[1]));
}
function cleanup() {
fileActionUploadRef.value?.cleanup();
fileActionUploadLinkRef.value?.cleanup();
VersionCachesController.deleteAllFileCaches();
setDataSource([]);
}
vue.onMounted(async () => {
await retriggerHandleDataSource();
});
vue.watch(() => mergedProps.value.mode, async () => {
cleanup();
});
vue.watch(() => JSON.stringify(mergedProps.value.apiParams), async (curApiParams, preApiParams) => {
if (curApiParams && curApiParams !== preApiParams) {
if (!mergedProps.value.dataSource) {
const curoptions = apiQueryFileOptions(mergedProps.value.apiParams);
if (!curoptions)
return;
const preoptions = apiQueryFileOptions(JSON.parse(preApiParams));
if (!preoptions)
return;
if (JSON.stringify(curoptions.apiParams) !== JSON.stringify(preoptions.apiParams)) {
loading.value.value = true;
await refreshCardDataApiAction(curoptions.apiParams);
loading.value.value = false;
}
}
}
});
vue.watch(() => JSON.stringify(mergedProps.value.dataSource), async (curdatasource, predatasource) => {
if (curdatasource && curdatasource !== predatasource) {
VersionCachesController.deleteAllFileCaches();
await retriggerHandleDataSource();
}
});
vue.onBeforeUnmount(() => {
cleanup();
});
expose({
fileActionUploadRef,
fileActionUploadLinkRef,
cleanup,
reload: refreshCardDataApiAction,
createRows: cardCreateRows,
readRows: cardReadRows,
updateRows: cardUpdateRows,
deleteRows: cardDeleteRows,
getDataSource: () => dataSource.value,
validate: (callback) => validate("change", callback),
clearValidate: () => {
validateMessage.value = "";
}
});
return (_ctx, _cache) => {
return vue.unref(mergedProps).visible ? (vue.openBlock(), vue.createElementBlock("section", {
key: 0,
id: vue.unref(DEFAULT_FILECARD_ID),
class: vue.normalizeClass({
[vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)]: true,
[`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}--${vue.unref(mergedProps).value}`]: vue.unref(mergedProps).value,
[`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}--uploaded`]: vue.unref(dataSource) && vue.unref(dataSource).length > 0,
[`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}--required`]: vue.unref(isRequired),
[`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}--validated-error`]: !!validateMessage.value
}),
style: vue.normalizeStyle(vue.unref(attrs).style)
}, [
vue.unref(mergedProps).headerVisible ? (vue.openBlock(), vue.createElementBlock("section", {
key: 0,
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-header`)
}, [
vue.unref(mergedProps).labelVisible ? (vue.openBlock(), vue.createElementBlock("div", {
key: 0,
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-meta`)
}, [
vue.createElementVNode("span", {
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-meta__label-required`)
}, "*", 2),
vue.createElementVNode("div", {
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-meta__label-wrapper`)
}, [
vue.createVNode(vue.unref(antDesignVue.Tooltip), {
placement: "top",
"destroy-tooltip-on-hide": true
}, {
title: vue.withCtx(() => [
vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(mergedProps).label), 1)
]),
default: vue.withCtx(() => [
vue.createElementVNode("span", {
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-meta__label`)
}, vue.toDisplayString(vue.unref(mergedProps).label), 3)
]),
_: 1
}),
vue.createCommentVNode(" <span :class=\"`${DEFAULT_FILECARD_CLASSNAME}-meta__upload-status`\">\n {{\n dataSource && dataSource.length > 0\n ? tavI18n('Tav.file.cards.2')\n : tavI18n('Tav.file.cards.1')\n }}\n </span> ")
], 2)
], 2)) : vue.createCommentVNode("v-if", true),
vue.unref(mergedProps).headerActionsVisible && vue.unref(mergedProps).mode !== "read" ? (vue.openBlock(), vue.createElementBlock("div", {
key: 1,
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-actions`)
}, [
vue.createVNode(vue.unref(antDesignVue.ButtonGroup), null, {
default: vue.withCtx(() => [
vue.createVNode(vue.unref(index.TaFileActionUploadLink), vue.mergeProps({
ref: (_value, _refs) => {
_refs["fileActionUploadLinkRef"] = _value;
fileActionUploadLinkRef.value = _value;
}
}, vue.unref(fileActionUploadLinkProps), {
onValidateSuccessChange: handleFileActionUploadLinkChangeValidateSuccessChange,
onValidateFailureChange: handleFileActionUploadLinkChangeValidateFailureChange,
onUploadedChange: handleFileActionUploadLinkChange
}), null, 16),
vue.createVNode(vue.unref(index$1.TaFileActionUpload), vue.mergeProps({
ref: (_value, _refs) => {
_refs["fileActionUploadRef"] = _value;
fileActionUploadRef.value = _value;
}
}, vue.unref(fileActionUploadProps), {
onValidateSuccessChange: handleFileActionUploadChangeValidateSuccessChange,
onValidateFailureChange: handleFileActionUploadChangeValidateFailureChange,
onUploadedChange: handleFileActionUploadChange
}), vue.createSlots({ _: 2 }, [
vue.unref(slots)["FileActionUploadButton"] ? {
name: "FileActionUploadButton",
fn: vue.withCtx((data) => [
vue.renderSlot(_ctx.$slots, "FileActionUploadButton", vue.normalizeProps(vue.guardReactiveProps(data || {})))
])
} : void 0
]), 1040)
]),
_: 3
})
], 2)) : vue.createCommentVNode("v-if", true)
], 2)) : vue.createCommentVNode("v-if", true),
vue.unref(mergedProps).headerVisible ? (vue.openBlock(), vue.createElementBlock("section", {
key: 1,
ref: (_value, _refs) => {
_refs["headerExtraElRef"] = _value;
headerExtraElRef.value = _value;
},
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-header-extra`)
}, null, 2)) : vue.createCommentVNode("v-if", true),
vue.unref(dataSource) && vue.unref(dataSource).length > 0 ? (vue.openBlock(), vue.createElementBlock("section", {
key: 2,
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-main`),
style: vue.normalizeStyle(vue.unref(mergedProps).maxHeight ? { maxHeight: `${vue.unref(mergedProps).maxHeight}px`, overflowY: "auto" } : {})
}, [
vue.createVNode(vue.unref(antDesignVue.List), {
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-list`),
"item-layout": "horizontal",
loading: vue.unref(loading).value,
"data-source": vue.unref(dataSource)
}, {
renderItem: vue.withCtx(({ item }) => [
vue.createVNode(vue.unref(ListItem["default"]), {
key: item.id,
row: item,
renders: vue.unref(items),
"class-name": `${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-list-item`,
"edit-config": vue.unref(editConfig)
}, null, 8, ["row", "renders", "class-name", "edit-config"])
]),
_: 1
}, 8, ["class", "loading", "data-source"]),
vue.createVNode(vue.unref(index$1.TaFileActionUpload), {
ref: (_value, _refs) => {
_refs["FileActionUploadForActionUpdateBtnRef"] = _value;
FileActionUploadForActionUpdateBtnRef.value = _value;
},
mode: vue.unref(mergedProps).mode,
"api-params": vue.unref(mergedProps).apiParams,
"validate-type-code": false,
"update-file": actionUpdateClickRow.value,
onUploadedChange: handleFileActionUploadForActionUpdateBtnChange
}, null, 8, ["mode", "api-params", "update-file"]),
vue.createVNode(vue.unref(index$2.TaFileVersion), {
visible: fileVersionModalVisible.value,
"onUpdate:visible": _cache[0] || (_cache[0] = ($event) => fileVersionModalVisible.value = $event),
mode: vue.unref(mergedProps).mode,
immediate: vue.unref(mergedProps).mode === "update" || vue.unref(mergedProps).mode === "updateInstantly" ? false : true,
"api-params": vue.unref(mergedProps).apiParams,
file: fileVersionFile.value,
"data-source": fileVersionDataSource.value
}, null, 8, ["visible", "mode", "immediate", "api-params", "file", "data-source"]),
vue.createCommentVNode(' :actions="handleFileVersionActions" \u9700\u8981\u65F6\u518D\u5F00\u542F '),
vue.createVNode(vue.unref(index$3.TaFilePreview), {
visible: filePreviewModalVisible.value,
"onUpdate:visible": _cache[1] || (_cache[1] = ($event) => filePreviewModalVisible.value = $event),
mode: vue.unref(mergedProps).mode,
immediate: true,
"api-params": vue.unref(mergedProps).apiParams,
file: filePreviewFile.value
}, null, 8, ["visible", "mode", "api-params", "file"]),
vue.createVNode(vue.unref(index$4.TaFileLog), {
visible: fileLogModalVisible.value,
"onUpdate:visible": _cache[2] || (_cache[2] = ($event) => fileLogModalVisible.value = $event),
mode: vue.unref(mergedProps).mode,
"api-params": vue.unref(mergedProps).apiParams,
file: fileLogFile.value
}, null, 8, ["visible", "mode", "api-params", "file"])
], 6)) : vue.createCommentVNode("v-if", true),
vue.createElementVNode("section", {
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-footer`)
}, [
!!validateMessage.value ? (vue.openBlock(), vue.createElementBlock("div", {
key: 0,
class: vue.normalizeClass(`${vue.unref(consts.DEFAULT_FILECARD_CLASSNAME)}-error-message`),
innerHTML: validateMessage.value
}, null, 10, _hoisted_2)) : vue.createCommentVNode("v-if", true)
], 2)
], 14, _hoisted_1)) : vue.createCommentVNode("v-if", true);
};
}
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
...__default__,
props: types.fileCardProps,
emits: types.fileCardEmits,
setup
});
var FileCard = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "/home/runner/work/tav-ui/tav-ui/packages/components/file/src/FileCard/index.vue"]]);
exports["default"] = FileCard;
//# sourceMappingURL=index3.js.map