@kp-ui/lowcode 0.0.1 → 1.0.1

package/AttachmentRender-DrVXpYQp.mjs

@@ -0,0 +1,783 @@
+import { createVNode, ref, defineComponent, onMounted, computed, resolveComponent, createElementBlock, createCommentVNode, openBlock, createElementVNode, withCtx, Fragment, renderList, createBlock, unref, toDisplayString } from "vue";
+import { Image, Button } from "ant-design-vue";
+import { I as Icon, u as useFilesystemApi, g as getUserInfo, S as SvgIcon, _ as _export_sfc } from "./install-2qAQyqq8.mjs";
+var DownloadOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M505.7 661a8 8 0 0012.6 0l112-141.7c4.1-5.2.4-12.9-6.3-12.9h-74.1V168c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v338.3H400c-6.7 0-10.4 7.7-6.3 12.9l112 141.8zM878 626h-60c-4.4 0-8 3.6-8 8v154H214V634c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v198c0 17.7 14.3 32 32 32h684c17.7 0 32-14.3 32-32V634c0-4.4-3.6-8-8-8z" } }] }, "name": "download", "theme": "outlined" };
+function _objectSpread$2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty$2(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function _defineProperty$2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var DownloadOutlined = function DownloadOutlined2(props, context) {
+  var p = _objectSpread$2({}, props, context.attrs);
+  return createVNode(Icon, _objectSpread$2({}, p, {
+    "icon": DownloadOutlined$1
+  }), null);
+};
+DownloadOutlined.displayName = "DownloadOutlined";
+DownloadOutlined.inheritAttrs = false;
+var EyeOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M942.2 486.2C847.4 286.5 704.1 186 512 186c-192.2 0-335.4 100.5-430.2 300.3a60.3 60.3 0 000 51.5C176.6 737.5 319.9 838 512 838c192.2 0 335.4-100.5 430.2-300.3 7.7-16.2 7.7-35 0-51.5zM512 766c-161.3 0-279.4-81.8-362.7-254C232.6 339.8 350.7 258 512 258c161.3 0 279.4 81.8 362.7 254C791.5 684.2 673.4 766 512 766zm-4-430c-97.2 0-176 78.8-176 176s78.8 176 176 176 176-78.8 176-176-78.8-176-176-176zm0 288c-61.9 0-112-50.1-112-112s50.1-112 112-112 112 50.1 112 112-50.1 112-112 112z" } }] }, "name": "eye", "theme": "outlined" };
+function _objectSpread$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty$1(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var EyeOutlined = function EyeOutlined2(props, context) {
+  var p = _objectSpread$1({}, props, context.attrs);
+  return createVNode(Icon, _objectSpread$1({}, p, {
+    "icon": EyeOutlined$1
+  }), null);
+};
+EyeOutlined.displayName = "EyeOutlined";
+EyeOutlined.inheritAttrs = false;
+var FileOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0042 42h216v494z" } }] }, "name": "file", "theme": "outlined" };
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var FileOutlined = function FileOutlined2(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": FileOutlined$1
+  }), null);
+};
+FileOutlined.displayName = "FileOutlined";
+FileOutlined.inheritAttrs = false;
+const token = "%[a-f0-9]{2}";
+const singleMatcher = new RegExp("(" + token + ")|([^%]+?)", "gi");
+const multiMatcher = new RegExp("(" + token + ")+", "gi");
+function decodeComponents(components, split) {
+  try {
+    return [decodeURIComponent(components.join(""))];
+  } catch {
+  }
+  if (components.length === 1) {
+    return components;
+  }
+  split = split || 1;
+  const left = components.slice(0, split);
+  const right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode$1(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch {
+    let tokens = input.match(singleMatcher) || [];
+    for (let i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join("");
+      tokens = input.match(singleMatcher) || [];
+    }
+    return input;
+  }
+}
+function customDecodeURIComponent(input) {
+  const replaceMap = {
+    "%FE%FF": "��",
+    "%FF%FE": "��"
+  };
+  let match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch {
+      const result = decode$1(match[0]);
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+    match = multiMatcher.exec(input);
+  }
+  replaceMap["%C2"] = "�";
+  const entries = Object.keys(replaceMap);
+  for (const key of entries) {
+    input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+  }
+  return input;
+}
+function decodeUriComponent(encodedURI) {
+  if (typeof encodedURI !== "string") {
+    throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+  }
+  try {
+    return decodeURIComponent(encodedURI);
+  } catch {
+    return customDecodeURIComponent(encodedURI);
+  }
+}
+function includeKeys(object, predicate) {
+  const result = {};
+  if (Array.isArray(predicate)) {
+    for (const key of predicate) {
+      const descriptor = Object.getOwnPropertyDescriptor(object, key);
+      if (descriptor == null ? void 0 : descriptor.enumerable) {
+        Object.defineProperty(result, key, descriptor);
+      }
+    }
+  } else {
+    for (const key of Reflect.ownKeys(object)) {
+      const descriptor = Object.getOwnPropertyDescriptor(object, key);
+      if (descriptor.enumerable) {
+        const value = object[key];
+        if (predicate(key, value, object)) {
+          Object.defineProperty(result, key, descriptor);
+        }
+      }
+    }
+  }
+  return result;
+}
+function splitOnFirst(string, separator) {
+  if (!(typeof string === "string" && typeof separator === "string")) {
+    throw new TypeError("Expected the arguments to be of type `string`");
+  }
+  if (string === "" || separator === "") {
+    return [];
+  }
+  const separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [];
+  }
+  return [
+    string.slice(0, separatorIndex),
+    string.slice(separatorIndex + separator.length)
+  ];
+}
+const isNullOrUndefined = (value) => value === null || value === void 0;
+const strictUriEncode = (string) => encodeURIComponent(string).replaceAll(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+const encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+function encoderForArrayFormat(options) {
+  switch (options.arrayFormat) {
+    case "index": {
+      return (key) => (result, value) => {
+        const index = result.length;
+        if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+          return result;
+        }
+        if (value === null) {
+          return [
+            ...result,
+            [encode(key, options), "[", index, "]"].join("")
+          ];
+        }
+        return [
+          ...result,
+          [encode(key, options), "[", encode(index, options), "]=", encode(value, options)].join("")
+        ];
+      };
+    }
+    case "bracket": {
+      return (key) => (result, value) => {
+        if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+          return result;
+        }
+        if (value === null) {
+          return [
+            ...result,
+            [encode(key, options), "[]"].join("")
+          ];
+        }
+        return [
+          ...result,
+          [encode(key, options), "[]=", encode(value, options)].join("")
+        ];
+      };
+    }
+    case "colon-list-separator": {
+      return (key) => (result, value) => {
+        if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+          return result;
+        }
+        if (value === null) {
+          return [
+            ...result,
+            [encode(key, options), ":list="].join("")
+          ];
+        }
+        return [
+          ...result,
+          [encode(key, options), ":list=", encode(value, options)].join("")
+        ];
+      };
+    }
+    case "comma":
+    case "separator":
+    case "bracket-separator": {
+      const keyValueSeparator = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+      return (key) => (result, value) => {
+        if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+          return result;
+        }
+        value = value === null ? "" : value;
+        if (result.length === 0) {
+          return [[encode(key, options), keyValueSeparator, encode(value, options)].join("")];
+        }
+        return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+      };
+    }
+    default: {
+      return (key) => (result, value) => {
+        if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+          return result;
+        }
+        if (value === null) {
+          return [
+            ...result,
+            encode(key, options)
+          ];
+        }
+        return [
+          ...result,
+          [encode(key, options), "=", encode(value, options)].join("")
+        ];
+      };
+    }
+  }
+}
+function parserForArrayFormat(options) {
+  let result;
+  switch (options.arrayFormat) {
+    case "index": {
+      return (key, value, accumulator) => {
+        result = /\[(\d*)]$/.exec(key);
+        key = key.replace(/\[\d*]$/, "");
+        if (!result) {
+          accumulator[key] = value;
+          return;
+        }
+        if (accumulator[key] === void 0) {
+          accumulator[key] = {};
+        }
+        accumulator[key][result[1]] = value;
+      };
+    }
+    case "bracket": {
+      return (key, value, accumulator) => {
+        result = /(\[])$/.exec(key);
+        key = key.replace(/\[]$/, "");
+        if (!result) {
+          accumulator[key] = value;
+          return;
+        }
+        if (accumulator[key] === void 0) {
+          accumulator[key] = [value];
+          return;
+        }
+        accumulator[key] = [...accumulator[key], value];
+      };
+    }
+    case "colon-list-separator": {
+      return (key, value, accumulator) => {
+        result = /(:list)$/.exec(key);
+        key = key.replace(/:list$/, "");
+        if (!result) {
+          accumulator[key] = value;
+          return;
+        }
+        if (accumulator[key] === void 0) {
+          accumulator[key] = [value];
+          return;
+        }
+        accumulator[key] = [...accumulator[key], value];
+      };
+    }
+    case "comma":
+    case "separator": {
+      return (key, value, accumulator) => {
+        const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+        const isEncodedArray = typeof value === "string" && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
+        value = isEncodedArray ? decode(value, options) : value;
+        const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode(item, options)) : value === null ? value : decode(value, options);
+        accumulator[key] = newValue;
+      };
+    }
+    case "bracket-separator": {
+      return (key, value, accumulator) => {
+        const isArray = /(\[])$/.test(key);
+        key = key.replace(/\[]$/, "");
+        if (!isArray) {
+          accumulator[key] = value ? decode(value, options) : value;
+          return;
+        }
+        const arrayValue = value === null ? [] : decode(value, options).split(options.arrayFormatSeparator);
+        if (accumulator[key] === void 0) {
+          accumulator[key] = arrayValue;
+          return;
+        }
+        accumulator[key] = [...accumulator[key], ...arrayValue];
+      };
+    }
+    default: {
+      return (key, value, accumulator) => {
+        if (accumulator[key] === void 0) {
+          accumulator[key] = value;
+          return;
+        }
+        accumulator[key] = [...[accumulator[key]].flat(), value];
+      };
+    }
+  }
+}
+function validateArrayFormatSeparator(value) {
+  if (typeof value !== "string" || value.length !== 1) {
+    throw new TypeError("arrayFormatSeparator must be single character string");
+  }
+}
+function encode(value, options) {
+  if (options.encode) {
+    return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+  }
+  return value;
+}
+function decode(value, options) {
+  if (options.decode) {
+    return decodeUriComponent(value);
+  }
+  return value;
+}
+function keysSorter(input) {
+  if (Array.isArray(input)) {
+    return input.sort();
+  }
+  if (typeof input === "object") {
+    return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
+  }
+  return input;
+}
+function removeHash(input) {
+  const hashStart = input.indexOf("#");
+  if (hashStart !== -1) {
+    input = input.slice(0, hashStart);
+  }
+  return input;
+}
+function getHash(url) {
+  let hash = "";
+  const hashStart = url.indexOf("#");
+  if (hashStart !== -1) {
+    hash = url.slice(hashStart);
+  }
+  return hash;
+}
+function parseValue(value, options, type) {
+  if (type === "string" && typeof value === "string") {
+    return value;
+  }
+  if (typeof type === "function" && typeof value === "string") {
+    return type(value);
+  }
+  if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+    return value.toLowerCase() === "true";
+  }
+  if (type === "number" && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+    return Number(value);
+  }
+  if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+    return Number(value);
+  }
+  return value;
+}
+function extract(input) {
+  input = removeHash(input);
+  const queryStart = input.indexOf("?");
+  if (queryStart === -1) {
+    return "";
+  }
+  return input.slice(queryStart + 1);
+}
+function parse(query, options) {
+  options = {
+    decode: true,
+    sort: true,
+    arrayFormat: "none",
+    arrayFormatSeparator: ",",
+    parseNumbers: false,
+    parseBooleans: false,
+    types: /* @__PURE__ */ Object.create(null),
+    ...options
+  };
+  validateArrayFormatSeparator(options.arrayFormatSeparator);
+  const formatter = parserForArrayFormat(options);
+  const returnValue = /* @__PURE__ */ Object.create(null);
+  if (typeof query !== "string") {
+    return returnValue;
+  }
+  query = query.trim().replace(/^[?#&]/, "");
+  if (!query) {
+    return returnValue;
+  }
+  for (const parameter of query.split("&")) {
+    if (parameter === "") {
+      continue;
+    }
+    const parameter_ = options.decode ? parameter.replaceAll("+", " ") : parameter;
+    let [key, value] = splitOnFirst(parameter_, "=");
+    if (key === void 0) {
+      key = parameter_;
+    }
+    value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode(value, options);
+    formatter(decode(key, options), value, returnValue);
+  }
+  for (const [key, value] of Object.entries(returnValue)) {
+    if (typeof value === "object" && value !== null && options.types[key] !== "string") {
+      for (const [key2, value2] of Object.entries(value)) {
+        const type = options.types[key] ? options.types[key].replace("[]", "") : void 0;
+        value[key2] = parseValue(value2, options, type);
+      }
+    } else if (typeof value === "object" && value !== null && options.types[key] === "string") {
+      returnValue[key] = Object.values(value).join(options.arrayFormatSeparator);
+    } else {
+      returnValue[key] = parseValue(value, options, options.types[key]);
+    }
+  }
+  if (options.sort === false) {
+    return returnValue;
+  }
+  return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce((result, key) => {
+    const value = returnValue[key];
+    result[key] = Boolean(value) && typeof value === "object" && !Array.isArray(value) ? keysSorter(value) : value;
+    return result;
+  }, /* @__PURE__ */ Object.create(null));
+}
+function stringify(object, options) {
+  if (!object) {
+    return "";
+  }
+  options = {
+    encode: true,
+    strict: true,
+    arrayFormat: "none",
+    arrayFormatSeparator: ",",
+    ...options
+  };
+  validateArrayFormatSeparator(options.arrayFormatSeparator);
+  const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+  const formatter = encoderForArrayFormat(options);
+  const objectCopy = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (!shouldFilter(key)) {
+      objectCopy[key] = value;
+    }
+  }
+  const keys = Object.keys(objectCopy);
+  if (options.sort !== false) {
+    keys.sort(options.sort);
+  }
+  return keys.map((key) => {
+    const value = object[key];
+    if (value === void 0) {
+      return "";
+    }
+    if (value === null) {
+      return encode(key, options);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+        return encode(key, options) + "[]";
+      }
+      return value.reduce(formatter(key), []).join("&");
+    }
+    return encode(key, options) + "=" + encode(value, options);
+  }).filter((x) => x.length > 0).join("&");
+}
+function parseUrl(url, options) {
+  var _a;
+  options = {
+    decode: true,
+    ...options
+  };
+  let [url_, hash] = splitOnFirst(url, "#");
+  if (url_ === void 0) {
+    url_ = url;
+  }
+  return {
+    url: ((_a = url_ == null ? void 0 : url_.split("?")) == null ? void 0 : _a[0]) ?? "",
+    query: parse(extract(url), options),
+    ...options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {}
+  };
+}
+function stringifyUrl(object, options) {
+  options = {
+    encode: true,
+    strict: true,
+    [encodeFragmentIdentifier]: true,
+    ...options
+  };
+  const url = removeHash(object.url).split("?")[0] || "";
+  const queryFromUrl = extract(object.url);
+  const query = {
+    ...parse(queryFromUrl, { sort: false }),
+    ...object.query
+  };
+  let queryString2 = stringify(query, options);
+  queryString2 && (queryString2 = `?${queryString2}`);
+  let hash = getHash(object.url);
+  if (typeof object.fragmentIdentifier === "string") {
+    const urlObjectForFragmentEncode = new URL(url);
+    urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+    hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : `#${object.fragmentIdentifier}`;
+  }
+  return `${url}${queryString2}${hash}`;
+}
+function pick(input, filter, options) {
+  options = {
+    parseFragmentIdentifier: true,
+    [encodeFragmentIdentifier]: false,
+    ...options
+  };
+  const { url, query, fragmentIdentifier } = parseUrl(input, options);
+  return stringifyUrl({
+    url,
+    query: includeKeys(query, filter),
+    fragmentIdentifier
+  }, options);
+}
+function exclude(input, filter, options) {
+  const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
+  return pick(input, exclusionFilter, options);
+}
+const queryString = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  exclude,
+  extract,
+  parse,
+  parseUrl,
+  pick,
+  stringify,
+  stringifyUrl
+}, Symbol.toStringTag, { value: "Module" }));
+const getDoMain = () => {
+  return window.location.origin;
+};
+function useFilePreview() {
+  const fileUrlCache = ref(/* @__PURE__ */ new Map());
+  const filesystemApi = useFilesystemApi();
+  const getPreviewFileUrl = async (fileCode) => {
+    if (fileUrlCache.value.has(fileCode)) {
+      return fileUrlCache.value.get(fileCode);
+    }
+    const fileUrlObj = await filesystemApi.getPreviewFileUrl({ fileCode });
+    fileUrlCache.value.set(fileCode, fileUrlObj.data.value);
+    return fileUrlObj.data.value;
+  };
+  const getPreviewData = async (data) => {
+    const res = data.map(async (item) => {
+      return {
+        ...item,
+        previewUrl: await getPreviewFileUrl(item.fileCode)
+      };
+    });
+    return Promise.all(res);
+  };
+  const handlePreview = async (file) => {
+    var _a, _b;
+    if (![".png", ".jpg", ".jpeg", ".gif"].includes(file.fileType || "")) {
+      const localUserInfo = getUserInfo();
+      const employeeId = (_a = localUserInfo == null ? void 0 : localUserInfo.loginInfo) == null ? void 0 : _a.employeeId;
+      const { tokenId, tenantId } = (_b = localUserInfo == null ? void 0 : localUserInfo.loginInfo) == null ? void 0 : _b.userToken;
+      const doMain = getDoMain();
+      const obj = {
+        tenantId,
+        tokenId,
+        employeeId,
+        fileCode: file.fileCode
+      };
+      console.log({ doMain });
+      window.open(`${doMain}/view-file/preview?${queryString.stringify(obj)}`);
+    }
+  };
+  const handleDownload = async (file) => {
+    try {
+      await filesystemApi.downloadFileObject({ fileCode: file.fileCode });
+    } catch (error) {
+      console.error("下载文件失败:", error);
+    }
+  };
+  return {
+    fileUrlCache,
+    handleDownload,
+    handlePreview,
+    getPreviewData,
+    getPreviewFileUrl
+  };
+}
+const FileIcon = /* @__PURE__ */ defineComponent({
+  name: "FileIcon",
+  props: {
+    file: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    return () => {
+      const fieldTypes = props.file.fileType || "";
+      try {
+        if ([".xls", ".xlsx"].includes(fieldTypes.toLowerCase())) {
+          return createVNode(SvgIcon, {
+            "icon-class": "excel"
+          }, null);
+        }
+        if ([".doc", ".docx"].includes(fieldTypes.toLowerCase())) {
+          return createVNode(SvgIcon, {
+            "icon-class": "word"
+          }, null);
+        }
+        if ([".pdf"].includes(fieldTypes.toLowerCase())) {
+          return createVNode(SvgIcon, {
+            "icon-class": "pdf"
+          }, null);
+        }
+      } catch {
+      }
+      return createVNode(FileOutlined, null, null);
+    };
+  }
+});
+const _hoisted_1 = {
+  key: 0,
+  class: "attachment-render"
+};
+const _hoisted_2 = { class: "file-list" };
+const _hoisted_3 = { class: "image-preview" };
+const _hoisted_4 = { class: "file-name" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "AttachmentRender",
+  props: {
+    data: { default: () => [] }
+  },
+  setup(__props) {
+    const props = __props;
+    const { getPreviewData, handlePreview, handleDownload } = useFilePreview();
+    const attachmentList = ref([]);
+    ref(false);
+    onMounted(async () => {
+      let data = props.data || [];
+      if (typeof data === "string") {
+        data = JSON.parse(data);
+      }
+      if ((data == null ? void 0 : data.length) === 0) {
+        attachmentList.value = [];
+        return;
+      }
+      attachmentList.value = await getPreviewData(data);
+    });
+    const isImageFile = (file) => {
+      const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"];
+      return imageExtensions.some((ext) => file.fileType.toLowerCase().endsWith(ext));
+    };
+    const fileList = computed(() => {
+      return attachmentList.value.filter((file) => !isImageFile(file));
+    });
+    const imageList = computed(() => {
+      return attachmentList.value.filter((file) => isImageFile(file));
+    });
+    return (_ctx, _cache) => {
+      const _component_a_image_preview_group = resolveComponent("a-image-preview-group");
+      return attachmentList.value.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            createVNode(_component_a_image_preview_group, null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(imageList.value, (file) => {
+                  return openBlock(), createBlock(unref(Image), {
+                    key: file.fileCode,
+                    src: file.previewUrl,
+                    class: "preview-image"
+                  }, null, 8, ["src"]);
+                }), 128))
+              ]),
+              _: 1
+            })
+          ]),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(fileList.value, (file, index) => {
+            return openBlock(), createElementBlock("div", {
+              key: index,
+              class: "file-item"
+            }, [
+              createVNode(unref(FileIcon), { file }, null, 8, ["file"]),
+              createElementVNode("span", _hoisted_4, toDisplayString(file.fileName), 1),
+              createVNode(unref(Button), {
+                type: "link",
+                onClick: () => unref(handleDownload)(file)
+              }, {
+                icon: withCtx(() => [
+                  createVNode(unref(DownloadOutlined))
+                ]),
+                _: 2
+              }, 1032, ["onClick"]),
+              createVNode(unref(Button), {
+                type: "link",
+                onClick: () => unref(handlePreview)(file)
+              }, {
+                icon: withCtx(() => [
+                  createVNode(unref(EyeOutlined))
+                ]),
+                _: 2
+              }, 1032, ["onClick"])
+            ]);
+          }), 128))
+        ])
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+const AttachmentRender = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c0780063"]]);
+export {
+  AttachmentRender as default
+};
+//# sourceMappingURL=AttachmentRender-DrVXpYQp.mjs.map