tav-ui/es/packages/components/file/src/FileCard/index3.mjs

Tav UI

import { ref, useSlots, useAttrs, watch, computed, toRaw, onMounted, onBeforeUnmount, unref, openBlock, createElementBlock, normalizeClass, normalizeStyle, createElementVNode, createVNode, withCtx, toDisplayString, createCommentVNode, mergeProps, createSlots, renderSlot, normalizeProps, guardReactiveProps, defineComponent } from 'vue';
import { Tooltip, ButtonGroup, List } from 'ant-design-vue';
import AsyncValidator from 'async-validator';
import '../../../../locales/index2.mjs';
import { useMessage } from '../../../../hooks/web/useMessage2.mjs';
import { useGlobalConfig } from '../../../../hooks/global/useGlobalConfig2.mjs';
import { TaFileActionUploadLink } from '../components/FileActionUploadLink/index4.mjs';
import { TaFileActionUpload } from '../components/FileActionUpload/index3.mjs';
import '../hooks/index2.mjs';
import '../utils/index2.mjs';
import { DEFAULT_FILECARD_CLASSNAME, DEFAULT_APIPARAMS } from '../consts2.mjs';
import { TaFileVersion } from '../components/FileVersion/index3.mjs';
import { TaFileLog } from '../components/FileLog/index4.mjs';
import { TaFilePreview } from '../components/FilePreview/index3.mjs';
import { fileCardProps, fileCardEmits } from './types2.mjs';
import './hooks/index2.mjs';
import ListItem from './components/ListItem2.mjs';
import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.mjs';
import { createId } from '../utils/setup2.mjs';
import { VersionCaches } from '../hooks/version-caches2.mjs';
import { useGlobalConfigProps, useMergedProps } from '../hooks/use-props2.mjs';
import { useDisable } from '../hooks/use-disable2.mjs';
import { useLoading } from '../hooks/use-loading2.mjs';
import { useRequest } from '../hooks/use-request2.mjs';
import { useHandleDataSource } from './hooks/use-handle-data-source2.mjs';
import { useMode } from './hooks/use-mode2.mjs';
import { useCardActions } from './hooks/use-card-actions2.mjs';
import { useDataSource } from './hooks/use-data-source2.mjs';
import { extendCurrentRowActionsAuth } from '../utils/extend2.mjs';
import { fileSingleDownload } from '../utils/download2.mjs';
import { useActions } from './hooks/use-actions2.mjs';
import { useItems } from './hooks/use-items2.mjs';
import { isFullNameColEdit } from '../utils/visibile2.mjs';
import { tavI18n } from '../../../../locales/transfer2.mjs';
import { useRules } from './hooks/use-rules2.mjs';

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 = createId(DEFAULT_FILECARD_CLASSNAME);
  const { createMessage } = useMessage();
  const headerExtraElRef = ref();
  const slots = useSlots();
  const attrs = useAttrs();
  const FileActionUploadForActionUpdateBtnRef = ref();
  const VersionCachesController = new VersionCaches();
  const globalConfigProps = useGlobalConfigProps();
  const mergedProps = useMergedProps(globalConfigProps, props, "TaFileCard", {
    ...DEFAULT_APIPARAMS
  });
  const fileApiParams = ref(props.apiParams);
  watch(() => JSON.stringify(props.apiParams), async (curapiParams, preapiParams) => {
    if (curapiParams !== preapiParams) {
      fileApiParams.value = props.apiParams;
    }
  });
  const fileActionUploadRef = ref();
  const fileActionUploadProps = 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 ?? DEFAULT_APIPARAMS.businessParamsJson,
        fileName: fileApiParams.value.fileName,
        ...props.fileActionUpload?.apiParams ?? {}
      },
      buttonType: "primary",
      buttonSize: "small",
      buttonIcon: false
    };
  });
  const fileActionUploadLinkRef = ref();
  const fileActionUploadLinkProps = 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 ?? DEFAULT_APIPARAMS.businessParamsJson,
        ...props.fileActionUploadLink?.apiParams ?? {}
      },
      getFormContainer: () => headerExtraElRef.value,
      buttonSize: "small",
      buttonIcon: false
    };
  });
  const _loading = ref(mergedProps.value.loading);
  const loading = computed({
    get() {
      return _loading;
    },
    set(newLoading) {
      _loading.value = newLoading.value;
    }
  });
  const { setDisable } = useDisable();
  const { setLoading } = useLoading();
  const {
    result: ApiResult,
    error: ApiError,
    handleApi
  } = useRequest({
    setDisable,
    setLoading,
    loading
  });
  const hasEmptyDataSource = computed(() => {
    return mergedProps.value.__dataSourceFromCards || !mergedProps.value.dataSource;
  });
  const {
    apiActions: { apiQueryFileOptions },
    dataSource,
    handleDataSource,
    setDataSource,
    handleApiDataSource
  } = useHandleDataSource({
    mergedProps,
    emits,
    VersionCachesController,
    ApiResult,
    ApiError,
    handleApi
  });
  const {
    apiActions: { rowEditorApiOptions, historyApiOptions, deleteApiOptions },
    dataActions: { reloadRows, editRow, updateRow, deleteRow }
  } = useMode({
    mergedProps,
    emits,
    VersionCachesController,
    handleApiDataSource,
    hasEmptyDataSource
  });
  const { cardCreateRows, cardReadRows, cardUpdateRows, cardDeleteRows } = useCardActions({
    mergedProps,
    dataSource,
    setDataSource,
    loading
  });
  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 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, 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 = ref(false);
  const fileVersionFile = ref();
  const fileVersionDataSource = 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 = ref(false);
  const filePreviewFile = ref();
  function handleViewBtnClick(row) {
    filePreviewModalVisible.value = true;
    filePreviewFile.value = row;
  }
  const actionUpdateClickRow = 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 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 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 = ref(false);
  const fileLogFile = ref();
  async function handleLogBtnClick(row) {
    fileLogFile.value = row;
    fileLogModalVisible.value = true;
  }
  const globalConfigUserInfo = useGlobalConfig("userInfo");
  const actions = useActions({
    mergedProps,
    handleViewBtnClick,
    handleUpdateBtnClick,
    handleDownloadWatermarkBtnClick,
    handleDownloadBtnClick,
    handleDeleteBtnClick,
    handleLogBtnClick,
    globalConfigUserInfo,
    VersionCachesController
  });
  const items = useItems({
    mergedProps,
    actions,
    handleRowEditClick,
    hanldeVersionClick
  });
  const editConfig = computed(() => mergedProps.value.enabledRowEdit ? {
    trigger: "click",
    mode: "cell",
    autoClear: true,
    beforeEditMethod: ({ row: _row }) => {
      const row = _row;
      const isEdit = isFullNameColEdit(mergedProps.value.enabledRowEdit, mergedProps.value.mode, mergedProps.value.enabledOwner, globalConfigUserInfo.value, row.owner);
      if (!isEdit) {
        createMessage.warn(`${tavI18n("Tav.common.notAuthorised")}`);
      }
      return isEdit;
    }
  } : void 0);
  const rules = useRules({
    mergedProps
  });
  const isRequired = computed(() => !!rules.value.find((rule) => rule.required));
  function getRuleByTriggerName(trigger) {
    return (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 = 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({ [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([]);
  }
  onMounted(async () => {
    await retriggerHandleDataSource();
  });
  watch(() => mergedProps.value.mode, async () => {
    cleanup();
  });
  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;
        }
      }
    }
  });
  watch(() => JSON.stringify(mergedProps.value.dataSource), async (curdatasource, predatasource) => {
    if (curdatasource && curdatasource !== predatasource) {
      VersionCachesController.deleteAllFileCaches();
      await retriggerHandleDataSource();
    }
  });
  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 unref(mergedProps).visible ? (openBlock(), createElementBlock("section", {
      key: 0,
      id: unref(DEFAULT_FILECARD_ID),
      class: normalizeClass({
        [unref(DEFAULT_FILECARD_CLASSNAME)]: true,
        [`${unref(DEFAULT_FILECARD_CLASSNAME)}--${unref(mergedProps).value}`]: unref(mergedProps).value,
        [`${unref(DEFAULT_FILECARD_CLASSNAME)}--uploaded`]: unref(dataSource) && unref(dataSource).length > 0,
        [`${unref(DEFAULT_FILECARD_CLASSNAME)}--required`]: unref(isRequired),
        [`${unref(DEFAULT_FILECARD_CLASSNAME)}--validated-error`]: !!validateMessage.value
      }),
      style: normalizeStyle(unref(attrs).style)
    }, [
      unref(mergedProps).headerVisible ? (openBlock(), createElementBlock("section", {
        key: 0,
        class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-header`)
      }, [
        unref(mergedProps).labelVisible ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-meta`)
        }, [
          createElementVNode("span", {
            class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-meta__label-required`)
          }, "*", 2),
          createElementVNode("div", {
            class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-meta__label-wrapper`)
          }, [
            createVNode(unref(Tooltip), {
              placement: "top",
              "destroy-tooltip-on-hide": true
            }, {
              title: withCtx(() => [
                createElementVNode("span", null, toDisplayString(unref(mergedProps).label), 1)
              ]),
              default: withCtx(() => [
                createElementVNode("span", {
                  class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-meta__label`)
                }, toDisplayString(unref(mergedProps).label), 3)
              ]),
              _: 1
            }),
            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)) : createCommentVNode("v-if", true),
        unref(mergedProps).headerActionsVisible && unref(mergedProps).mode !== "read" ? (openBlock(), createElementBlock("div", {
          key: 1,
          class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-actions`)
        }, [
          createVNode(unref(ButtonGroup), null, {
            default: withCtx(() => [
              createVNode(unref(TaFileActionUploadLink), mergeProps({
                ref: (_value, _refs) => {
                  _refs["fileActionUploadLinkRef"] = _value;
                  fileActionUploadLinkRef.value = _value;
                }
              }, unref(fileActionUploadLinkProps), {
                onValidateSuccessChange: handleFileActionUploadLinkChangeValidateSuccessChange,
                onValidateFailureChange: handleFileActionUploadLinkChangeValidateFailureChange,
                onUploadedChange: handleFileActionUploadLinkChange
              }), null, 16),
              createVNode(unref(TaFileActionUpload), mergeProps({
                ref: (_value, _refs) => {
                  _refs["fileActionUploadRef"] = _value;
                  fileActionUploadRef.value = _value;
                }
              }, unref(fileActionUploadProps), {
                onValidateSuccessChange: handleFileActionUploadChangeValidateSuccessChange,
                onValidateFailureChange: handleFileActionUploadChangeValidateFailureChange,
                onUploadedChange: handleFileActionUploadChange
              }), createSlots({ _: 2 }, [
                unref(slots)["FileActionUploadButton"] ? {
                  name: "FileActionUploadButton",
                  fn: withCtx((data) => [
                    renderSlot(_ctx.$slots, "FileActionUploadButton", normalizeProps(guardReactiveProps(data || {})))
                  ])
                } : void 0
              ]), 1040)
            ]),
            _: 3
          })
        ], 2)) : createCommentVNode("v-if", true)
      ], 2)) : createCommentVNode("v-if", true),
      unref(mergedProps).headerVisible ? (openBlock(), createElementBlock("section", {
        key: 1,
        ref: (_value, _refs) => {
          _refs["headerExtraElRef"] = _value;
          headerExtraElRef.value = _value;
        },
        class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-header-extra`)
      }, null, 2)) : createCommentVNode("v-if", true),
      unref(dataSource) && unref(dataSource).length > 0 ? (openBlock(), createElementBlock("section", {
        key: 2,
        class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-main`),
        style: normalizeStyle(unref(mergedProps).maxHeight ? { maxHeight: `${unref(mergedProps).maxHeight}px`, overflowY: "auto" } : {})
      }, [
        createVNode(unref(List), {
          class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-list`),
          "item-layout": "horizontal",
          loading: unref(loading).value,
          "data-source": unref(dataSource)
        }, {
          renderItem: withCtx(({ item }) => [
            createVNode(unref(ListItem), {
              key: item.id,
              row: item,
              renders: unref(items),
              "class-name": `${unref(DEFAULT_FILECARD_CLASSNAME)}-list-item`,
              "edit-config": unref(editConfig)
            }, null, 8, ["row", "renders", "class-name", "edit-config"])
          ]),
          _: 1
        }, 8, ["class", "loading", "data-source"]),
        createVNode(unref(TaFileActionUpload), {
          ref: (_value, _refs) => {
            _refs["FileActionUploadForActionUpdateBtnRef"] = _value;
            FileActionUploadForActionUpdateBtnRef.value = _value;
          },
          mode: unref(mergedProps).mode,
          "api-params": unref(mergedProps).apiParams,
          "validate-type-code": false,
          "update-file": actionUpdateClickRow.value,
          onUploadedChange: handleFileActionUploadForActionUpdateBtnChange
        }, null, 8, ["mode", "api-params", "update-file"]),
        createVNode(unref(TaFileVersion), {
          visible: fileVersionModalVisible.value,
          "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => fileVersionModalVisible.value = $event),
          mode: unref(mergedProps).mode,
          immediate: unref(mergedProps).mode === "update" || unref(mergedProps).mode === "updateInstantly" ? false : true,
          "api-params": unref(mergedProps).apiParams,
          file: fileVersionFile.value,
          "data-source": fileVersionDataSource.value
        }, null, 8, ["visible", "mode", "immediate", "api-params", "file", "data-source"]),
        createCommentVNode(' :actions="handleFileVersionActions" \u9700\u8981\u65F6\u518D\u5F00\u542F '),
        createVNode(unref(TaFilePreview), {
          visible: filePreviewModalVisible.value,
          "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => filePreviewModalVisible.value = $event),
          mode: unref(mergedProps).mode,
          immediate: true,
          "api-params": unref(mergedProps).apiParams,
          file: filePreviewFile.value
        }, null, 8, ["visible", "mode", "api-params", "file"]),
        createVNode(unref(TaFileLog), {
          visible: fileLogModalVisible.value,
          "onUpdate:visible": _cache[2] || (_cache[2] = ($event) => fileLogModalVisible.value = $event),
          mode: unref(mergedProps).mode,
          "api-params": unref(mergedProps).apiParams,
          file: fileLogFile.value
        }, null, 8, ["visible", "mode", "api-params", "file"])
      ], 6)) : createCommentVNode("v-if", true),
      createElementVNode("section", {
        class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-footer`)
      }, [
        !!validateMessage.value ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: normalizeClass(`${unref(DEFAULT_FILECARD_CLASSNAME)}-error-message`),
          innerHTML: validateMessage.value
        }, null, 10, _hoisted_2)) : createCommentVNode("v-if", true)
      ], 2)
    ], 14, _hoisted_1)) : createCommentVNode("v-if", true);
  };
}
const _sfc_main = /* @__PURE__ */ defineComponent({
  ...__default__,
  props: fileCardProps,
  emits: fileCardEmits,
  setup
});
var FileCard = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/tav-ui/tav-ui/packages/components/file/src/FileCard/index.vue"]]);

export { FileCard as default };
//# sourceMappingURL=index3.mjs.map