@cmstops/pro-compo 0.1.20 → 0.1.22

package/lib/editMetaInfo/components/metaInfoForm.js

@@ -0,0 +1,622 @@
+"use strict";
+var vue = require("vue");
+var webVue = require("@arco-design/web-vue");
+var doc = require("../../utils/doc.js");
+var component = require("../../selectThumb/component.js");
+var restaurants = require("../script/restaurants.js");
+var api = require("../script/api.js");
+var config = require("../../config.js");
+var index = require("../../utils/index.js");
+const _sfc_main = vue.defineComponent({
+  __name: "metaInfoForm",
+  props: {
+    initData: {},
+    BASE_API: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const BASE_API = props.BASE_API || config.DEFAULT_BASE_API;
+    const metaInfoFormRef = vue.ref();
+    const form = vue.ref({
+      title: "",
+      style: "",
+      sub_title: "",
+      head_title: "",
+      summary: "",
+      brief: "",
+      guide: "",
+      keywords: [],
+      author: "",
+      duty_editor: "",
+      extra_attrs: [],
+      self_publish_time: "",
+      line_time: false,
+      online_time: "",
+      offline_time: "",
+      source: "",
+      source_url: "",
+      statement: false,
+      aiRelated: false,
+      relation_news: "",
+      ori_count: false,
+      ori_read_count: 0,
+      ori_thumbup_count: 0,
+      comment_available: false,
+      is_recommend: false,
+      album_status: false
+    });
+    const rules = {
+      title: [
+        { required: true, message: "\u8BF7\u8F93\u5165\u4E3B\u6807\u9898" },
+        { min: 2, max: 100, message: "\u957F\u5EA6\u5728 2 \u5230 100 \u4E2A\u5B57\u7B26" }
+      ],
+      style: [{ required: true, message: "\u8BF7\u9009\u62E9\u6837\u5F0F" }],
+      source: [{ required: true, message: "\u8BF7\u9009\u62E9\u6765\u6E90" }]
+    };
+    const series = vue.computed(() => {
+      var _a;
+      return (_a = props.initData) == null ? void 0 : _a.series;
+    });
+    const showBrief = vue.computed(() => {
+      return [
+        "video",
+        "special",
+        "special_v3",
+        "video_album",
+        "audio_album"
+      ].includes(series.value);
+    });
+    const dutyEditorOptions = vue.ref([]);
+    const getAllDutyEditorOption = async () => {
+      const { code, message } = await api.getAllDutyEditor(BASE_API);
+      if (code === 0) {
+        dutyEditorOptions.value = message.data.map((item) => {
+          return {
+            value: item.alias,
+            label: item.alias
+          };
+        });
+      }
+    };
+    const lineTimeChange = () => {
+      form.value.online_time = "";
+      form.value.offline_time = "";
+    };
+    const docBrief = vue.computed(() => {
+      var _a;
+      return ((_a = doc.docSeries[series.value]) == null ? void 0 : _a.replace("\u7A3F\u4EF6", "")) || "";
+    });
+    const isAlbumStatus = vue.computed(() => {
+      return ["video_album", "audio_album"].includes(series.value);
+    });
+    const disabledStartTime = (time) => {
+      return time <= Date.now() - 864e5;
+    };
+    const disabledEndTime = (time) => {
+      return time < Date.now() - 864e5;
+    };
+    const styleValidator = (data) => {
+      var _a;
+      if (data && data.style) {
+        const style = JSON.parse(data.style);
+        if (![0, 4].includes(style.model) && !(style.data && style.data.length)) {
+          webVue.Message.warning("\u9009\u62E9\u65E0\u5C01\u9762\u56FE\u6A21\u5F0F\u65F6\uFF0C\u9700\u8981\u9009\u62E9\u5C01\u9762\u56FE");
+          return false;
+        }
+        if (style.model === 1 && !(style.data && style.data.length === 3)) {
+          webVue.Message.warning("\u9009\u62E9\u4E09\u56FE\u5C01\u9762\u6A21\u5F0F\u65F6\uFF0C\u9700\u8981\u5C06\u5C01\u9762\u6570\u91CF\u8865\u5145\u5B8C\u6574");
+          return false;
+        }
+        if (style.banner && !style.banner_url) {
+          webVue.Message.warning("\u5F00\u542F\u72EC\u7ACB\u8F6E\u64AD\u56FE\u6A21\u5F0F\u65F6\uFF0C\u9700\u8981\u9009\u62E9\u8F6E\u64AD\u56FE");
+          return false;
+        }
+        if (["video_album", "audio_album", "special", "special_v3"].includes(
+          series.value
+        ) && !style.pc_banner_url) {
+          const title = ((_a = doc.docSeries[series.value]) == null ? void 0 : _a.replace("\u7A3F\u4EF6", "")) || "";
+          webVue.Message.warning(`\u8BF7\u4E0A\u4F20${title}\u5C01\u9762\u5934\u56FE`);
+          return false;
+        }
+      }
+      return true;
+    };
+    const getFormData = async (_valid = false) => {
+      if (_valid) {
+        const passRule = await index.validateForm(metaInfoFormRef);
+        if (!passRule) {
+          webVue.Message.warning("\u8BF7\u68C0\u67E5\u53D1\u5E03\u8BBE\u7F6E\u4FE1\u606F\u5FC5\u586B\u5B57\u6BB5\u662F\u5426\u9057\u6F0F");
+          return false;
+        }
+      }
+      const data = vue.toRaw(form.value);
+      data.self_publish_time = data.self_publish_time && Math.floor(data.self_publish_time / 1e3);
+      data.online_time = data.online_time && Math.floor(data.online_time / 1e3);
+      data.offline_time = data.offline_time && Math.floor(data.offline_time / 1e3);
+      data.keywords = data.keywords && data.keywords.join(",");
+      data.author = data.author && data.author.join(",");
+      data.duty_editor = data.duty_editor && data.duty_editor.join(",");
+      data.extra_attrs = data.extra_attrs && data.extra_attrs.join(",");
+      data.relation_news = data.relation_news && JSON.stringify(data.relation_news);
+      data.comment_available = data.comment_available ? "true" : "false";
+      data.statement = data.statement ? "true" : "false";
+      data.is_recommend = data.is_recommend ? "true" : "false";
+      data.album_status = data.album_status ? 1 : 0;
+      delete data.line_time;
+      delete data.ori_count;
+      delete data.aiRelated;
+      Object.keys(data).map((key) => {
+        if (typeof data[key] !== "string") {
+          data[key] += "";
+        }
+        if (data[key] === "NaN") {
+          data[key] = "";
+        }
+        return key;
+      });
+      if (!styleValidator(data))
+        return false;
+      return data;
+    };
+    const loadData = () => {
+      const data = { ...props.initData };
+      data.self_publish_time = data.self_publish_time && parseInt(data.self_publish_time, 10) * 1e3 || "";
+      data.online_time = data.online_time && parseInt(data.online_time, 10) * 1e3 || "";
+      data.offline_time = data.offline_time && parseInt(data.offline_time, 10) * 1e3 || "";
+      data.keywords = data.keywords && data.keywords.split(",");
+      data.author = data.author && data.author.split(",");
+      data.duty_editor = data.duty_editor && data.duty_editor.split(",") || "";
+      data.extra_attrs = data.extra_attrs && data.extra_attrs.split(",") || "";
+      data.relation_news = data.relation_news && JSON.parse(data.relation_news) || [];
+      data.line_time = !!(data.online_time || data.offline_time);
+      data.ori_read_count = Number(data.ori_read_count);
+      data.ori_thumbup_count = Number(data.ori_thumbup_count);
+      data.ori_count = !!(data.ori_read_count || data.ori_thumbup_count);
+      data.comment_available = data.comment_available !== "false";
+      data.statement = data.statement !== "false";
+      data.is_recommend = data.is_recommend !== "false";
+      data.album_status = data.album_status !== "0";
+      Object.assign(form.value, data);
+    };
+    vue.watch(
+      () => props.initData,
+      () => {
+        if (props.initData) {
+          loadData();
+        }
+      },
+      { immediate: true }
+    );
+    vue.onMounted(() => {
+      getAllDutyEditorOption();
+    });
+    __expose({
+      getFormData
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(webVue.Form), {
+        ref_key: "metaInfoFormRef",
+        ref: metaInfoFormRef,
+        rules,
+        class: "meta-info-form",
+        model: form.value
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "title",
+            field: "title",
+            label: "\u4E3B\u6807\u9898"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.title,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => form.value.title = $event),
+                class: "input-w",
+                placeholder: "\u4E3B\u6807\u9898",
+                "max-length": "100",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.withDirectives(vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "brief",
+            field: "brief",
+            label: `${docBrief.value}\u63CF\u8FF0`
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.brief,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => form.value.brief = $event),
+                class: "input-w",
+                placeholder: `\u586B\u5199${docBrief.value}\u63CF\u8FF0`,
+                "max-length": "300",
+                "allow-clear": ""
+              }, null, 8, ["modelValue", "placeholder"])
+            ]),
+            _: 1
+          }, 8, ["label"]), [
+            [vue.vShow, showBrief.value]
+          ]),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "style",
+            field: "style",
+            "hide-label": "",
+            "content-class": "style-form-item"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(component, {
+                dataValue: form.value.style,
+                "onUpdate:dataValue": _cache[2] || (_cache[2] = ($event) => form.value.style = $event),
+                series: series.value,
+                class: "select-thumb-wrap",
+                mode: "doc"
+              }, null, 8, ["dataValue", "series"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "sub_title",
+            field: "sub_title",
+            label: "\u526F\u6807\u9898"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.sub_title,
+                "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => form.value.sub_title = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u526F\u6807\u9898",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "head_title",
+            field: "head_title",
+            label: "\u5F15\u6807\u9898"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.head_title,
+                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => form.value.head_title = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u5F15\u6807\u9898",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "summary",
+            field: "summary",
+            label: "\u6458\u8981"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.summary,
+                "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => form.value.summary = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u6458\u8981",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "guide",
+            field: "guide",
+            label: "\u5BFC\u8BFB"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.guide,
+                "onUpdate:modelValue": _cache[6] || (_cache[6] = ($event) => form.value.guide = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u5BFC\u8BFB",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "keywords",
+            field: "keywords",
+            label: "\u8BBE\u7F6E\u5173\u952E\u8BCD"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.InputTag), {
+                modelValue: form.value.keywords,
+                "onUpdate:modelValue": _cache[7] || (_cache[7] = ($event) => form.value.keywords = $event),
+                class: "input-w",
+                placeholder: "\u8BBE\u7F6E\u5173\u952E\u8BCD",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "source",
+            field: "source",
+            label: "\u6765\u6E90\u540D\u79F0"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Select), {
+                modelValue: form.value.source,
+                "onUpdate:modelValue": _cache[8] || (_cache[8] = ($event) => form.value.source = $event),
+                class: "input-w",
+                placeholder: "\u8BF7\u9009\u62E9"
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(restaurants), (item) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(webVue.Option), {
+                      key: item.value,
+                      value: item.value,
+                      label: item.value
+                    }, null, 8, ["value", "label"]);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "source_url",
+            field: "source_url",
+            label: "\u6765\u6E90URL"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.source_url,
+                "onUpdate:modelValue": _cache[9] || (_cache[9] = ($event) => form.value.source_url = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u6765\u6E90URL",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "author",
+            field: "author",
+            label: "\u4F5C\u8005"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Input), {
+                modelValue: form.value.author,
+                "onUpdate:modelValue": _cache[10] || (_cache[10] = ($event) => form.value.author = $event),
+                class: "input-w",
+                placeholder: "\u586B\u5199\u4F5C\u8005",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "duty_editor",
+            field: "duty_editor",
+            label: "\u7F16\u8F91"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Select), {
+                modelValue: form.value.duty_editor,
+                "onUpdate:modelValue": _cache[11] || (_cache[11] = ($event) => form.value.duty_editor = $event),
+                multiple: "",
+                class: "input-w",
+                placeholder: "\u8BBE\u7F6E\u7F16\u8F91"
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(dutyEditorOptions.value, (item) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(webVue.Option), {
+                      key: item.value,
+                      value: item.value,
+                      label: item.label
+                    }, null, 8, ["value", "label"]);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "extra_attrs",
+            field: "extra_attrs",
+            label: "\u81EA\u5B9A\u4E49\u5C5E\u6027"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.InputTag), {
+                modelValue: form.value.extra_attrs,
+                "onUpdate:modelValue": _cache[12] || (_cache[12] = ($event) => form.value.extra_attrs = $event),
+                class: "input-w",
+                placeholder: "\u8BBE\u7F6E\u81EA\u5B9A\u4E49\u5C5E\u6027",
+                "allow-clear": ""
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "self_publish_time",
+            class: "horizontal",
+            field: "self_publish_time",
+            label: "\u81EA\u5B9A\u4E49\u53D1\u5E03\u65F6\u95F4"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.DatePicker), {
+                modelValue: form.value.self_publish_time,
+                "onUpdate:modelValue": _cache[13] || (_cache[13] = ($event) => form.value.self_publish_time = $event),
+                "show-time": "",
+                placeholder: "\u9009\u62E9\u81EA\u5B9A\u4E49\u53D1\u5E03\u65F6\u95F4",
+                "time-picker-props": { defaultValue: "12:00:00" },
+                "value-format": "timestamp"
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "line_time",
+            class: "horizontal",
+            field: "line_time",
+            label: "\u5B9A\u65F6\u4E0A\u4E0B\u7EBF"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.line_time,
+                "onUpdate:modelValue": _cache[14] || (_cache[14] = ($event) => form.value.line_time = $event),
+                onChange: lineTimeChange
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "online_time",
+            class: "horizontal",
+            field: "online_time",
+            label: "\u4E0A\u7EBF\u65F6\u95F4"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.DatePicker), {
+                modelValue: form.value.online_time,
+                "onUpdate:modelValue": _cache[15] || (_cache[15] = ($event) => form.value.online_time = $event),
+                "show-time": "",
+                placeholder: "\u9009\u62E9\u4E0A\u7EBF\u65F6\u95F4",
+                "time-picker-props": { defaultValue: "12:00:00" },
+                "value-format": "timestamp",
+                "disabled-date": disabledStartTime
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "offline_time",
+            class: "horizontal",
+            field: "offline_time",
+            label: "\u4E0B\u7EBF\u65F6\u95F4"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.DatePicker), {
+                modelValue: form.value.offline_time,
+                "onUpdate:modelValue": _cache[16] || (_cache[16] = ($event) => form.value.offline_time = $event),
+                "show-time": "",
+                placeholder: "\u9009\u62E9\u4E0B\u7EBF\u65F6\u95F4",
+                "time-picker-props": { defaultValue: "12:00:00" },
+                "value-format": "timestamp",
+                "disabled-date": disabledEndTime
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "statement",
+            class: "horizontal",
+            field: "statement",
+            label: "\u539F\u521B\u58F0\u660E"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.statement,
+                "onUpdate:modelValue": _cache[17] || (_cache[17] = ($event) => form.value.statement = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "ori_count",
+            class: "horizontal",
+            field: "ori_count",
+            label: "\u4E92\u52A8\u6570\u636E"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.ori_count,
+                "onUpdate:modelValue": _cache[18] || (_cache[18] = ($event) => form.value.ori_count = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.withDirectives(vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "ori_read_count",
+            class: "horizontal",
+            field: "ori_read_count",
+            label: "\u521D\u59CB\u9605\u8BFB\u91CF"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.InputNumber), {
+                modelValue: form.value.ori_read_count,
+                "onUpdate:modelValue": _cache[19] || (_cache[19] = ($event) => form.value.ori_read_count = $event),
+                style: { width: "240px" }
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, form.value.ori_count]
+          ]),
+          vue.withDirectives(vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "ori_thumbup_count",
+            class: "horizontal",
+            field: "ori_thumbup_count",
+            label: "\u521D\u59CB\u70B9\u8D5E\u91CF"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.InputNumber), {
+                modelValue: form.value.ori_thumbup_count,
+                "onUpdate:modelValue": _cache[20] || (_cache[20] = ($event) => form.value.ori_thumbup_count = $event),
+                style: { width: "240px" }
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, form.value.ori_count]
+          ]),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "comment_available",
+            class: "horizontal",
+            field: "comment_available",
+            label: "\u5F00\u542F\u8BC4\u8BBA"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.comment_available,
+                "onUpdate:modelValue": _cache[21] || (_cache[21] = ($event) => form.value.comment_available = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "is_recommend",
+            class: "horizontal",
+            field: "is_recommend",
+            label: "\u662F\u5426\u63A8\u8350"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.is_recommend,
+                "onUpdate:modelValue": _cache[22] || (_cache[22] = ($event) => form.value.is_recommend = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.withDirectives(vue.createVNode(vue.unref(webVue.FormItem), {
+            key: "album_status",
+            class: "horizontal",
+            field: "album_status",
+            label: "\u662F\u5426\u5B8C\u7ED3"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(webVue.Switch), {
+                modelValue: form.value.album_status,
+                "onUpdate:modelValue": _cache[23] || (_cache[23] = ($event) => form.value.album_status = $event)
+              }, null, 8, ["modelValue"])
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, isAlbumStatus.value]
+          ])
+        ]),
+        _: 1
+      }, 8, ["model"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/editMetaInfo/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var component = require("./component.js");
+const editMetaInfo = Object.assign(component, {
+  install: (app) => {
+    app.component(component.name, component);
+  }
+});
+module.exports = editMetaInfo;

package/lib/editMetaInfo/script/api.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var request = require("../../utils/request.js");
+function getDocDetailsNew(BASE_API, query) {
+  const url = `/poplar/v3/document/${query.hashid}`;
+  const params = {};
+  return request(BASE_API, {
+    url,
+    method: "get",
+    params
+  });
+}
+function getAllDutyEditor(BASE_API, params) {
+  return request(BASE_API, {
+    url: `poplar/v2/account/aliases/duty`,
+    method: "get"
+  });
+}
+exports.getAllDutyEditor = getAllDutyEditor;
+exports.getDocDetailsNew = getDocDetailsNew;