@voicenter-team/voicenter-ui-plus 2.0.12 → 3.0.0

package/library/components/VcSparkline/helper.mjs

@@ -0,0 +1,98 @@
+function _genPath(points, radius, fill = false, height = 75) {
+  if (points.length === 0) return "";
+  const start = points.shift();
+  const end = points[points.length - 1];
+  return (fill ? `M${start.x} ${height - start.x + 2} L${start.x} ${start.y}` : `M${start.x} ${start.y}`) + points.map((point, index) => {
+    const next = points[index + 1];
+    const prev = points[index - 1] || start;
+    const isCollinear = next && checkCollinear(next, point, prev);
+    if (!next || isCollinear) {
+      return `L${point.x} ${point.y}`;
+    }
+    const threshold = Math.min(
+      getDistance(prev, point),
+      getDistance(next, point)
+    );
+    const isTooCloseForRadius = threshold / 2 < radius;
+    const radiusForPoint = isTooCloseForRadius ? threshold / 2 : radius;
+    const before = moveTo(prev, point, radiusForPoint);
+    const after = moveTo(next, point, radiusForPoint);
+    return `L${before.x} ${before.y}S${point.x} ${point.y} ${after.x} ${after.y}`;
+  }).join("") + (fill ? `L${end.x} ${height - start.x + 2} Z` : "");
+}
+function int(value) {
+  return parseInt(`${value}`, 10);
+}
+function checkCollinear(p0, p1, p2) {
+  return int(p0.x + p2.x) === int(2 * p1.x) && int(p0.y + p2.y) === int(2 * p1.y);
+}
+function getDistance(p1, p2) {
+  return Math.sqrt(
+    Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2)
+  );
+}
+function moveTo(to, from, radius) {
+  const vector = {
+    x: to.x - from.x,
+    y: to.y - from.y
+  };
+  const length = Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+  const unitVector = {
+    x: vector.x / length,
+    y: vector.y / length
+  };
+  return {
+    x: from.x + unitVector.x * radius,
+    y: from.y + unitVector.y * radius
+  };
+}
+function isKeyedRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function getPropertyFromItem(item, property, fallback) {
+  if (property === true) return item === void 0 ? fallback : item;
+  if (property == null || typeof property === "boolean") return fallback;
+  if (item !== Object(item)) {
+    if (typeof property !== "function") return fallback;
+    const value2 = property(item, fallback);
+    return typeof value2 === "undefined" ? fallback : value2;
+  }
+  if (typeof property === "string") return getObjectValueByPath(item, property, fallback);
+  if (Array.isArray(property)) return getNestedValue(item, property, fallback);
+  if (typeof property !== "function") return fallback;
+  const value = property(item, fallback);
+  return typeof value === "undefined" ? fallback : value;
+}
+function getObjectValueByPath(obj, path, fallback) {
+  if (obj == null || !path || typeof path !== "string") return fallback;
+  if (isKeyedRecord(obj)) {
+    const direct = obj[path];
+    if (direct !== void 0) return direct;
+  }
+  const normalized = path.replace(/\[(\w+)\]/g, ".$1").replace(/^\./, "");
+  return getNestedValue(obj, normalized.split("."), fallback);
+}
+function getNestedValue(obj, path, fallback) {
+  const last = path.length - 1;
+  if (last < 0) return obj === void 0 ? fallback : obj;
+  let current = obj;
+  for (let i = 0; i < last; i++) {
+    if (!isKeyedRecord(current)) {
+      return fallback;
+    }
+    current = current[path[i]];
+  }
+  if (!isKeyedRecord(current)) return fallback;
+  const value = current[path[last]];
+  return value === void 0 ? fallback : value;
+}
+export {
+  _genPath,
+  checkCollinear,
+  getDistance,
+  getNestedValue,
+  getObjectValueByPath,
+  getPropertyFromItem,
+  int,
+  moveTo
+};

package/library/components/VcSplitButton/VcSplitButton.vue.mjs

@@ -0,0 +1,179 @@
+import '../../assets/components/VcSplitButton/VcSplitButton.css';
+import { defineComponent, ref, computed, watch, openBlock, createElementBlock, normalizeClass, renderSlot, createElementVNode, createBlock, createCommentVNode, toDisplayString, createVNode, withCtx, withDirectives, Fragment, renderList, unref } from "vue";
+import _sfc_main$2 from "../VcPopover/VcPopover.vue.mjs";
+import '../../assets/components/VcIcon/VcIcon.css';import '../../assets/components/VcPopover/VcPopover.css';/* empty css                           */
+import _sfc_main$1 from "../VcIcon/VcIcon.vue.mjs";
+/* empty css                     */
+import { ClickOutside } from "element-plus";
+import uniqueComponentId from "../../utils/UniqueComponentId.mjs";
+const _hoisted_1 = ["disabled"];
+const _hoisted_2 = { class: "truncate" };
+const _hoisted_3 = ["disabled"];
+const _hoisted_4 = {
+  ref: "dropdown",
+  class: "flex flex-col divide-y divide-ui-lines"
+};
+const _hoisted_5 = ["onClick"];
+const _hoisted_6 = { class: "max-w-full truncate" };
+const _hoisted_7 = {
+  key: 0,
+  class: "vc-split-button--loader"
+};
+const DEFAULT_LOAD_ICON = "vc-icon-load";
+const CLASS_FOR_COLOR = "vc-split-button--";
+const DEFAULT_COLOR = "primary";
+const DEFAULT_SIZE = "default";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "VcSplitButton",
+  props: {
+    options: {},
+    color: { default: DEFAULT_COLOR },
+    disabled: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    teleported: { type: Boolean, default: true },
+    dataTestName: { default: uniqueComponentId("split-button") },
+    size: { default: DEFAULT_SIZE },
+    popoverMaxWidth: { default: "480" },
+    popoverWidth: { default: "auto" },
+    loaderIcon: { default: DEFAULT_LOAD_ICON }
+  },
+  emits: ["click", "change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = ref(false);
+    const selectedValue = ref(void 0);
+    const actionRef = ref();
+    const containerClasses = computed(() => {
+      const colorClass = CLASS_FOR_COLOR + props.color;
+      return [
+        colorClass,
+        {
+          "vc-split-button--disabled": props.disabled,
+          "is--loading": props.loading
+        },
+        props.size === DEFAULT_SIZE || `vc-split-button--${props.size}`
+      ];
+    });
+    const popoverClasses = computed(() => {
+      const classMain = "vc-split-button__dropdown";
+      return [
+        classMain,
+        props.size === "large" && "offset-y-1",
+        `is--${props.size}`
+      ].join(" ");
+    });
+    function handleOutsideClick() {
+      closeDropdown();
+    }
+    function closeDropdown() {
+      open.value = false;
+    }
+    function setOption(option) {
+      selectedValue.value = option;
+      closeDropdown();
+      emit("change", option);
+    }
+    function handleClick() {
+      emit("click", selectedValue.value);
+    }
+    function setFirstOption(option) {
+      selectedValue.value = option ? { ...option } : props.options[0];
+    }
+    watch(
+      () => props.options,
+      () => {
+        setFirstOption();
+      },
+      {
+        immediate: true
+      }
+    );
+    __expose({
+      refresh: setFirstOption,
+      handleOutsideClick
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref: "splitContainer",
+        class: normalizeClass([containerClasses.value, "vc-split-button"])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, () => {
+          var _a, _b;
+          return [
+            createElementVNode("button", {
+              disabled: __props.disabled,
+              type: "button",
+              class: "vc-split-button__button",
+              onClick: handleClick
+            }, [
+              ((_a = selectedValue.value) == null ? void 0 : _a.icon) ? (openBlock(), createBlock(_sfc_main$1, {
+                key: 0,
+                icon: selectedValue.value.icon,
+                class: "content-icon"
+              }, null, 8, ["icon"])) : createCommentVNode("", true),
+              createElementVNode("span", _hoisted_2, toDisplayString((_b = selectedValue.value) == null ? void 0 : _b.label), 1)
+            ], 8, _hoisted_1)
+          ];
+        }),
+        createVNode(_sfc_main$2, {
+          open: open.value,
+          "popover-class": popoverClasses.value,
+          placement: "bottom-end",
+          teleported: __props.teleported,
+          "popover-max-width": __props.popoverMaxWidth,
+          "popover-width": "auto",
+          trigger: "manual"
+        }, {
+          reference: withCtx(() => [
+            createElementVNode("button", {
+              ref_key: "actionRef",
+              ref: actionRef,
+              disabled: __props.disabled,
+              type: "button",
+              class: "vc-split-button__menubutton",
+              onClick: _cache[0] || (_cache[0] = ($event) => open.value = !open.value)
+            }, [
+              createVNode(_sfc_main$1, {
+                icon: "vc-icon-down",
+                class: normalizeClass({ "is-open": open.value })
+              }, null, 8, ["class"])
+            ], 8, _hoisted_3)
+          ]),
+          default: withCtx(() => [
+            withDirectives((openBlock(), createElementBlock("div", _hoisted_4, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (option, i) => {
+                return openBlock(), createElementBlock("div", {
+                  key: `option-${i}`,
+                  class: normalizeClass([`size-${__props.size} is--${__props.color}`, "vc-split-button__dropdown-option"]),
+                  onClick: ($event) => setOption(option)
+                }, [
+                  (option == null ? void 0 : option.icon) ? (openBlock(), createBlock(_sfc_main$1, {
+                    key: 0,
+                    icon: option.icon,
+                    class: "option-icon"
+                  }, null, 8, ["icon"])) : createCommentVNode("", true),
+                  createElementVNode("span", _hoisted_6, toDisplayString(option.label), 1)
+                ], 10, _hoisted_5);
+              }), 128))
+            ])), [
+              [unref(ClickOutside), handleOutsideClick, actionRef.value]
+            ])
+          ]),
+          _: 1
+        }, 8, ["open", "popover-class", "teleported", "popover-max-width"]),
+        __props.loading ? (openBlock(), createElementBlock("span", _hoisted_7, [
+          renderSlot(_ctx.$slots, "loader", {}, () => [
+            createVNode(_sfc_main$1, {
+              icon: __props.loaderIcon,
+              class: "text-current"
+            }, null, 8, ["icon"])
+          ])
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcSplitButton/VcSplitButton.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcSplitButton.vue.mjs";
+import '../../assets/components/VcSplitButton/VcSplitButton.css';/* empty css                    */
+export {
+  _sfc_main as default
+};

package/library/components/VcSwitch/VcSwitch.vue.mjs

@@ -0,0 +1,187 @@
+import { defineComponent, useSlots, computed, openBlock, createElementBlock, createVNode, unref, normalizeClass, createSlots, withCtx, renderSlot, createElementVNode, toDisplayString, createCommentVNode } from "vue";
+import { ElSwitch } from "element-plus";
+import '../../assets/node_modules/element-plus/theme-chalk/src/switch.css';import '../../assets/node_modules/element-plus/theme-chalk/src/base.css';
+import '../../assets/components/VcSwitch/VcSwitch.css';/* empty css                                                         */
+/* empty css                                                           */
+import { tVU } from "../../localization/index.mjs";
+const _hoisted_1 = { class: "vc-switch__wrap" };
+const COLOR_CLASS = "vc-switch-color-";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "VcSwitch",
+  props: {
+    id: { default: void 0 },
+    tabindex: { default: void 0 },
+    modelValue: {},
+    disabled: { type: Boolean, default: false },
+    loading: { type: Boolean },
+    color: { default: "active" },
+    size: { default: "default" },
+    width: { default: void 0 },
+    activeIcon: { default: void 0 },
+    inactiveIcon: { default: void 0 },
+    activeActionIcon: { default: void 0 },
+    inactiveActionIcon: { default: void 0 },
+    activeText: { default: void 0 },
+    inactiveText: { default: void 0 },
+    activeValue: { default: void 0 },
+    inactiveValue: { default: void 0 },
+    name: { default: void 0 },
+    validateEvent: { type: Boolean, default: true },
+    beforeChange: { type: Function, default: void 0 },
+    ariaLabel: { default: void 0 },
+    hideLabel: { type: Boolean, default: true },
+    labelClass: { default: "" },
+    dataTestName: { default: "default" },
+    values: { default: () => [] },
+    labels: { default: () => [] },
+    inlinePrompt: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "input", "change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    function isModel(val) {
+      return typeof val === "string" || typeof val === "number" || typeof val === "boolean";
+    }
+    const props = __props;
+    const slots = useSlots();
+    const emit = __emit;
+    const model = computed({
+      get() {
+        return props.modelValue;
+      },
+      set(value) {
+        emit("update:modelValue", value);
+        emit("input", value);
+      }
+    });
+    const colorClasses = computed(() => {
+      return props.color ? COLOR_CLASS + props.color : "";
+    });
+    const switchClass = computed(() => {
+      return `vc-switch-${model.value === activeDataValue.value ? "on" : "off"}`;
+    });
+    const visibleLabel = computed(() => {
+      var _a;
+      return !props.hideLabel || ((_a = props.labels) == null ? void 0 : _a.length) || slots.default;
+    });
+    const activeDataValue = computed(() => {
+      var _a, _b;
+      if (props.activeValue || ((_a = props.values) == null ? void 0 : _a.length)) {
+        return props.activeValue ?? ((_b = props.values) == null ? void 0 : _b[0]);
+      }
+      const fallback = typeof model.value === "number" ? 1 : true;
+      return isModel(fallback) ? fallback : void 0;
+    });
+    const inactiveDataValue = computed(() => {
+      var _a, _b;
+      if (props.inactiveValue || ((_a = props.values) == null ? void 0 : _a.length)) {
+        return props.inactiveValue ?? ((_b = props.values) == null ? void 0 : _b[1]);
+      }
+      const fallback = typeof model.value === "number" ? 0 : false;
+      return isModel(fallback) ? fallback : void 0;
+    });
+    const switchLabel = computed(() => {
+      var _a;
+      let labelEnabled = tVU.t("voicenterUi.general.enabled");
+      let labelDisabled = tVU.t("voicenterUi.general.disabled");
+      if ((_a = props.labels) == null ? void 0 : _a.length) {
+        labelEnabled = props.labels[0];
+        labelDisabled = props.labels[1];
+      }
+      return isEnabled.value ? labelEnabled : labelDisabled;
+    });
+    const commonLabelClass = computed(() => {
+      let _labelClass = "text-base";
+      if (props.labelClass) {
+        _labelClass = props.labelClass;
+      }
+      return _labelClass;
+    });
+    const isEnabled = computed(() => {
+      return model.value === activeDataValue.value;
+    });
+    const tabIndex = computed(() => {
+      return props.disabled ? -1 : 0;
+    });
+    function triggerToggle() {
+      var _a;
+      if (props.disabled) {
+        return;
+      }
+      if (((_a = props.values) == null ? void 0 : _a.length) || typeof model.value !== "boolean") {
+        const next2 = model.value === activeDataValue.value ? inactiveDataValue.value : activeDataValue.value;
+        if (next2 !== void 0) {
+          model.value = next2;
+        }
+        return;
+      }
+      const next = !model.value;
+      if (isModel(next)) {
+        model.value = next;
+      }
+    }
+    function onChange(val) {
+      if (isModel(val)) {
+        emit("change", val);
+      }
+    }
+    __expose({
+      toggle: triggerToggle
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(ElSwitch), {
+          id: __props.id,
+          modelValue: model.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event),
+          tabindex: tabIndex.value,
+          "aria-label": __props.ariaLabel,
+          "data-test": `switch-${__props.dataTestName}`,
+          disabled: __props.disabled,
+          size: __props.size,
+          width: __props.width,
+          loading: __props.loading,
+          "active-icon": __props.activeIcon,
+          "inactive-icon": __props.inactiveIcon,
+          "active-action-icon": __props.activeActionIcon,
+          "inactive-action-icon": __props.inactiveActionIcon,
+          "active-text": __props.activeText,
+          "inactive-text": __props.inactiveText,
+          "active-value": activeDataValue.value,
+          "inactive-value": inactiveDataValue.value,
+          "inline-prompt": __props.inlinePrompt,
+          name: __props.name,
+          "validate-event": __props.validateEvent,
+          "before-change": __props.beforeChange,
+          class: normalizeClass([[switchClass.value, colorClasses.value], "vc-switch"]),
+          onChange
+        }, createSlots({ _: 2 }, [
+          _ctx.$slots["active-action"] ? {
+            name: "active-action",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "active-action")
+            ]),
+            key: "0"
+          } : void 0,
+          _ctx.$slots["inactive-action"] ? {
+            name: "inactive-action",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "inactive-action")
+            ]),
+            key: "1"
+          } : void 0
+        ]), 1032, ["id", "modelValue", "tabindex", "aria-label", "data-test", "disabled", "size", "width", "loading", "active-icon", "inactive-icon", "active-action-icon", "inactive-action-icon", "active-text", "inactive-text", "active-value", "inactive-value", "inline-prompt", "name", "validate-event", "before-change", "class"]),
+        visibleLabel.value ? (openBlock(), createElementBlock("span", {
+          key: 0,
+          class: normalizeClass(["vc-switch-label", commonLabelClass.value])
+        }, [
+          renderSlot(_ctx.$slots, "default", { state: model.value }, () => [
+            createElementVNode("span", null, toDisplayString(switchLabel.value), 1)
+          ])
+        ], 2)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcSwitch/VcSwitch.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcSwitch.vue.mjs";
+import '../../assets/components/VcSwitch/VcSwitch.css';/* empty css               */
+export {
+  _sfc_main as default
+};

package/library/components/VcSystemUserPrompt/VcSystemUserPrompt.vue.mjs

@@ -0,0 +1,127 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, createElementVNode, createVNode, unref, withDirectives, vShow } from "vue";
+import { SYSTEM_USER_PROMPT_DEFAULT_TAB, systemUserPromptEnum, systemUserPromptOptions, SYSTEM_PROMPT_VALUE, USER_PROMPT_VALUE } from "./enum.mjs";
+import _sfc_main$2 from "../VcMdEditor/VcMdEditor.vue.mjs";
+import { useVModel } from "@vueuse/core";
+import _sfc_main$1 from "../VcViewSwitcher/VcViewSwitcher.vue.mjs";
+import '../../assets/components/VcViewSwitcher/VcViewSwitcher.css';/* empty css                                     */
+const _hoisted_1 = { class: "vc-system-user-prompt" };
+const _hoisted_2 = { class: "w-full vc-system-user-prompt__nav" };
+const _hoisted_3 = { class: "vc-system-user-prompt__content pt-4 pb-3" };
+const _hoisted_4 = { class: "vc-system-user-prompt__content-system" };
+const _hoisted_5 = { class: "vc-system-user-prompt__content-user" };
+const MIN_HEIGHT = 200;
+const MAX_HEIGHT = 600;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "VcSystemUserPrompt",
+  props: {
+    modelValue: {},
+    minHeight: {},
+    maxHeight: {},
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    isTeleported: { type: Boolean },
+    useParameters: { type: Boolean },
+    parameters: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const activeTab = ref(SYSTEM_USER_PROMPT_DEFAULT_TAB);
+    const localModel = useVModel(props, "modelValue", emit, {
+      deep: true,
+      passive: true
+    });
+    const systemPromptEditorRef = ref();
+    const userPromptEditorRef = ref();
+    const systemPromptModel = computed({
+      get() {
+        var _a;
+        return ((_a = localModel.value) == null ? void 0 : _a.system_prompt) ?? "";
+      },
+      set(val) {
+        const { user_prompt = "" } = localModel.value ?? {};
+        localModel.value = {
+          system_prompt: val,
+          user_prompt
+        };
+      }
+    });
+    const userPromptModel = computed({
+      get() {
+        var _a;
+        return ((_a = localModel.value) == null ? void 0 : _a.user_prompt) ?? "";
+      },
+      set(val) {
+        const { system_prompt = "" } = localModel.value ?? {};
+        localModel.value = {
+          user_prompt: val,
+          system_prompt
+        };
+      }
+    });
+    __expose({
+      validate: () => {
+        var _a, _b;
+        const systemPromptValidation = (_a = systemPromptEditorRef.value) == null ? void 0 : _a.validate();
+        const userPromptValidation = (_b = userPromptEditorRef.value) == null ? void 0 : _b.validate();
+        return {
+          isValid: (systemPromptValidation == null ? void 0 : systemPromptValidation.length) === 0 && (userPromptValidation == null ? void 0 : userPromptValidation.length) === 0,
+          systemPromptValidation,
+          userPromptValidation
+        };
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createVNode(_sfc_main$1, {
+            modelValue: activeTab.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => activeTab.value = $event),
+            options: unref(systemUserPromptOptions),
+            config: unref(systemUserPromptEnum)
+          }, null, 8, ["modelValue", "options", "config"])
+        ]),
+        createElementVNode("div", _hoisted_3, [
+          withDirectives(createElementVNode("div", _hoisted_4, [
+            createVNode(_sfc_main$2, {
+              ref_key: "systemPromptEditorRef",
+              ref: systemPromptEditorRef,
+              modelValue: systemPromptModel.value,
+              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => systemPromptModel.value = $event),
+              disabled: __props.disabled,
+              "min-height": __props.minHeight ?? MIN_HEIGHT,
+              "max-height": __props.maxHeight ?? MAX_HEIGHT,
+              "is-teleported": __props.isTeleported,
+              readonly: __props.readonly,
+              "use-parameters": __props.useParameters,
+              parameters: __props.parameters
+            }, null, 8, ["modelValue", "disabled", "min-height", "max-height", "is-teleported", "readonly", "use-parameters", "parameters"])
+          ], 512), [
+            [vShow, activeTab.value === unref(SYSTEM_PROMPT_VALUE)]
+          ]),
+          withDirectives(createElementVNode("div", _hoisted_5, [
+            createVNode(_sfc_main$2, {
+              ref_key: "userPromptEditorRef",
+              ref: userPromptEditorRef,
+              modelValue: userPromptModel.value,
+              "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => userPromptModel.value = $event),
+              disabled: __props.disabled,
+              "min-height": __props.minHeight ?? MIN_HEIGHT,
+              "max-height": __props.maxHeight ?? MAX_HEIGHT,
+              "is-teleported": __props.isTeleported,
+              readonly: __props.readonly,
+              "use-parameters": __props.useParameters,
+              parameters: __props.parameters
+            }, null, 8, ["modelValue", "disabled", "min-height", "max-height", "is-teleported", "readonly", "use-parameters", "parameters"])
+          ], 512), [
+            [vShow, activeTab.value === unref(USER_PROMPT_VALUE)]
+          ])
+        ])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcSystemUserPrompt/VcSystemUserPrompt.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./VcSystemUserPrompt.vue.mjs";
+export {
+  _sfc_main as default
+};

package/library/components/VcSystemUserPrompt/enum.mjs

@@ -0,0 +1,29 @@
+import { tVU } from "../../localization/index.mjs";
+import { AppWindow } from "@lucide/vue";
+const SYSTEM_USER_PROMPT_DEFAULT_TAB = "system";
+const SYSTEM_PROMPT_VALUE = "system";
+const USER_PROMPT_VALUE = "user";
+const systemUserPromptEnum = {
+  labelKey: "name",
+  valueKey: "key",
+  iconKey: "icon"
+};
+const systemUserPromptOptions = [
+  {
+    name: tVU.t("voicenterUi.systemPrompt.system").toString(),
+    key: SYSTEM_PROMPT_VALUE,
+    icon: AppWindow
+  },
+  {
+    name: tVU.t("voicenterUi.systemPrompt.user").toString(),
+    key: USER_PROMPT_VALUE,
+    icon: AppWindow
+  }
+];
+export {
+  SYSTEM_PROMPT_VALUE,
+  SYSTEM_USER_PROMPT_DEFAULT_TAB,
+  USER_PROMPT_VALUE,
+  systemUserPromptEnum,
+  systemUserPromptOptions
+};

package/library/components/VcTable/VcTable.vue.mjs

@@ -0,0 +1,8 @@
+import _sfc_main from "./VcTable.vue2.mjs";
+import '../../assets/components/VcTable/VcTable2.css';import '../../assets/components/VcTable/VcTable.css';/* empty css              */
+/* empty css              */
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const VcTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d465e664"]]);
+export {
+  VcTable as default
+};