qidian-vue-ui 2.6.0 → 2.6.1

package/dist/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,6 @@
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+export {
+  getDefaultExportFromCjs
+};

package/dist/_virtual/_plugin-vue_export-helper.mjs

@@ -0,0 +1,10 @@
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+export {
+  _export_sfc as default
+};

package/dist/_virtual/dayjs.min.mjs

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from "./_commonjsHelpers.mjs";
+import { __require as requireDayjs_min } from "../node_modules/.pnpm/dayjs@1.11.19/node_modules/dayjs/dayjs.min.mjs";
+var dayjs_minExports = requireDayjs_min();
+const dayjs = /* @__PURE__ */ getDefaultExportFromCjs(dayjs_minExports);
+export {
+  dayjs as default
+};

package/dist/_virtual/dayjs.min2.mjs

@@ -0,0 +1,4 @@
+var dayjs_min = { exports: {} };
+export {
+  dayjs_min as __module
+};

package/dist/codemirror.d.ts

@@ -0,0 +1 @@
+export * from './components/codemirror';

package/dist/codemirror.mjs

@@ -0,0 +1,6 @@
+import { default as default2 } from "./components/codemirror/languages.mjs";
+import { default as default3 } from "./components/codemirror/index.vue.mjs";
+export {
+  default3 as QdCodemirror,
+  default2 as QdCodemirrorLanguages
+};

package/dist/components/auto-tooltip/index.css

@@ -0,0 +1,20 @@
+.qd-auto-tooltip[data-v-42a59533] {
+  width: 100%;
+  display: flex;
+  align-items: center;
+}
+.qd-auto-tooltip .pre-wrap[data-v-42a59533] {
+  white-space: pre-wrap;
+}
+.qd-auto-tooltip__content[data-v-42a59533] {
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.qd-auto-tooltip__content--1[data-v-42a59533] {
+  white-space: nowrap;
+}
+.qd-auto-tooltip__content[data-v-42a59533]:not(.qd-auto-tooltip__content--1) {
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: var(--e7096996);
+}

package/dist/components/auto-tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as QdAutoTooltip } from './index.vue';
+export type { QdAutoTooltipProps } from './types';

package/dist/components/auto-tooltip/index.vue.d.ts

@@ -0,0 +1,25 @@
+import type { QdAutoTooltipProps } from './types';
+declare var __VLS_5: {}, __VLS_7: {}, __VLS_9: {}, __VLS_11: {}, __VLS_13: {};
+type __VLS_Slots = {} & {
+    content?: (props: typeof __VLS_5) => any;
+} & {
+    default?: (props: typeof __VLS_7) => any;
+} & {
+    default?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+} & {
+    suffix?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<QdAutoTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<QdAutoTooltipProps> & Readonly<{}>, {
+    attach: import("tdesign-vue-next").AttachNode;
+    ellipsis: number;
+    tooltipDisabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/auto-tooltip/index.vue.mjs

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

package/dist/components/auto-tooltip/index.vue2.mjs

@@ -0,0 +1,86 @@
+import './index.css'
+import { defineComponent, useCssVars, useTemplateRef, ref, computed, watch, nextTick, createElementBlock, openBlock, createVNode, renderSlot, unref, withCtx, withDirectives, normalizeClass, createTextVNode, toDisplayString } from "vue";
+import { resizeDirective } from "qidian-shared";
+import { Tooltip } from "tdesign-vue-next";
+import { reAttach } from "../../utils/tools.mjs";
+const _hoisted_1 = { class: "qd-auto-tooltip" };
+const _hoisted_2 = {
+  key: 0,
+  class: "pre-wrap"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdAutoTooltip"
+  },
+  __name: "index",
+  props: {
+    content: {},
+    preWrap: { type: Boolean },
+    ellipsis: { default: 1 },
+    tooltipDisabled: { type: Boolean, default: void 0 },
+    placement: {},
+    attach: { type: [String, Function], default: "body" },
+    theme: {}
+  },
+  setup(__props) {
+    useCssVars((_ctx) => ({
+      "e7096996": _ctx.ellipsis
+    }));
+    const props = __props;
+    const vResize = resizeDirective;
+    const contentRef = useTemplateRef("content");
+    const isEllipsis = ref(false);
+    const resolvedAttach = computed(() => reAttach(props.attach));
+    function checkEllipsis() {
+      const el = contentRef.value;
+      if (!el) return;
+      isEllipsis.value = el.scrollWidth > el.clientWidth || props.ellipsis > 1 && el.scrollHeight > el.clientHeight;
+    }
+    watch(
+      () => props.content,
+      () => {
+        nextTick(checkEllipsis);
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(Tooltip), {
+          attach: resolvedAttach.value,
+          placement: __props.placement,
+          disabled: __props.tooltipDisabled ?? !isEllipsis.value,
+          theme: __props.theme,
+          "destroy-on-close": ""
+        }, {
+          content: withCtx(() => [
+            renderSlot(_ctx.$slots, "content", {}, () => [
+              __props.preWrap ? (openBlock(), createElementBlock("span", _hoisted_2, [
+                renderSlot(_ctx.$slots, "default", {}, () => [
+                  createTextVNode(toDisplayString(__props.content), 1)
+                ], true)
+              ])) : renderSlot(_ctx.$slots, "default", { key: 1 }, () => [
+                createTextVNode(toDisplayString(__props.content), 1)
+              ], true)
+            ], true)
+          ]),
+          default: withCtx(() => [
+            withDirectives((openBlock(), createElementBlock("div", {
+              ref: "content",
+              class: normalizeClass(["qd-auto-tooltip__content", `qd-auto-tooltip__content--${__props.ellipsis}`])
+            }, [
+              renderSlot(_ctx.$slots, "default", {}, () => [
+                createTextVNode(toDisplayString(__props.content), 1)
+              ], true)
+            ], 2)), [
+              [unref(vResize), checkEllipsis]
+            ])
+          ]),
+          _: 3
+        }, 8, ["attach", "placement", "disabled", "theme"]),
+        renderSlot(_ctx.$slots, "suffix", {}, void 0, true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/auto-tooltip/types.d.ts

@@ -0,0 +1,7 @@
+import type { TdTooltipProps } from 'tdesign-vue-next';
+export interface QdAutoTooltipProps extends Pick<TdTooltipProps, 'placement' | 'attach' | 'theme'> {
+    content?: string;
+    preWrap?: boolean;
+    ellipsis?: number;
+    tooltipDisabled?: boolean;
+}

package/dist/components/avatar/index.css

@@ -0,0 +1,9 @@
+.qd-avatar[data-v-e6856505] {
+  display: inline-flex;
+  align-items: center;
+  font: var(--td-font-body-medium);
+  color: var(--td-text-color-primary);
+}
+.qd-avatar__name[data-v-e6856505] {
+  margin-left: var(--td-comp-margin-s);
+}

package/dist/components/avatar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as QdAvatar } from './index.vue';
+export type { QdAvatarProps } from './types';

package/dist/components/avatar/index.vue.d.ts

@@ -0,0 +1,18 @@
+import type { QdAvatarProps } from './types';
+declare var __VLS_5: {}, __VLS_12: string, __VLS_13: any;
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_12>]?: (props: typeof __VLS_13) => any;
+} & {
+    icon?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<QdAvatarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<QdAvatarProps> & Readonly<{}>, {
+    mode: "ossId" | "url";
+    hideOnLoadFailed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/avatar/index.vue.mjs

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

package/dist/components/avatar/index.vue2.mjs

@@ -0,0 +1,135 @@
+import './index.css'
+import { defineComponent, mergeDefaults, inject, computed, ref, watch, onUnmounted, createElementBlock, openBlock, withDirectives, createCommentVNode, createBlock, unref, mergeProps, createSlots, withCtx, renderSlot, createVNode, renderList, normalizeProps, guardReactiveProps, normalizeClass, toDisplayString } from "vue";
+import { isEmpty, validator, abortWrapper, to, filterSlots } from "qidian-shared";
+import { UserIcon } from "tdesign-icons-vue-next";
+import { Avatar, LoadingDirective } from "tdesign-vue-next";
+import { PROVIDE_AVATAR } from "../config-provider/config.mjs";
+import { qdAvatarImageProps, qdAvatarProps } from "./props.mjs";
+import { useUserAvatar } from "../../hooks/useUserAvatar/index.mjs";
+import merge from "../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/merge.mjs";
+const _hoisted_1 = { class: "qd-avatar" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdAvatar"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ mergeDefaults({
+    name: {},
+    mode: {},
+    avatarClassName: {},
+    nameClassName: {},
+    image: {},
+    alt: {},
+    content: {},
+    default: {},
+    hideOnLoadFailed: { type: Boolean },
+    icon: {},
+    imageProps: {},
+    shape: {},
+    size: {},
+    onError: { type: Function },
+    service: { type: Function }
+  }, qdAvatarProps),
+  setup(__props) {
+    const props = __props;
+    const vLoading = LoadingDirective;
+    const globalAvatarProps = inject(
+      PROVIDE_AVATAR,
+      computed(() => void 0)
+    );
+    const { loading, getAvatar } = useUserAvatar();
+    const serviceAbortReason = /* @__PURE__ */ Symbol("abort");
+    let serviceAbort;
+    const reImage = ref();
+    const reProps = computed(() => {
+      const {
+        name,
+        mode,
+        avatarClassName,
+        nameClassName,
+        image,
+        service,
+        imageProps,
+        ...avatarOptions
+      } = props;
+      const reAlt = avatarOptions.alt || name;
+      const serviceOptions = { service: service || globalAvatarProps.value?.service };
+      const reImageProps = merge({}, imageProps, qdAvatarImageProps);
+      return {
+        avatarOptions: {
+          ...avatarOptions,
+          imageProps: reImageProps,
+          alt: reAlt
+        },
+        serviceOptions,
+        name,
+        mode,
+        avatarClassName,
+        nameClassName,
+        image
+      };
+    });
+    watch(
+      () => reProps.value.image,
+      async (newVal, oldVal) => {
+        if (newVal === oldVal) return;
+        serviceAbort?.abort?.(serviceAbortReason);
+        serviceAbort = void 0;
+        const { mode, serviceOptions } = reProps.value;
+        if (mode === "ossId") {
+          const { service } = serviceOptions;
+          if (!service || isEmpty(newVal) || validator(newVal, "url")) {
+            reImage.value = newVal;
+            return;
+          }
+          const currentRequest = abortWrapper(getAvatar(newVal));
+          serviceAbort = currentRequest;
+          const [error, res] = await to(currentRequest);
+          if (serviceAbort !== currentRequest) return;
+          serviceAbort = void 0;
+          if (error) throw error;
+          reImage.value = res;
+          return;
+        }
+        reImage.value = newVal;
+      },
+      { immediate: true }
+    );
+    onUnmounted(() => {
+      serviceAbort?.abort?.(serviceAbortReason);
+      serviceAbort = void 0;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        withDirectives((openBlock(), createBlock(unref(Avatar), mergeProps({ class: __props.avatarClassName }, reProps.value.avatarOptions, {
+          image: typeof reImage.value === "number" ? reImage.value + "" : reImage.value
+        }), createSlots({
+          icon: withCtx(() => [
+            renderSlot(_ctx.$slots, "icon", {}, () => [
+              createVNode(unref(UserIcon))
+            ], true)
+          ]),
+          _: 2
+        }, [
+          renderList(unref(filterSlots)(_ctx.$slots, ["icon"]), (name) => {
+            return {
+              name,
+              fn: withCtx((slotProps) => [
+                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+              ])
+            };
+          })
+        ]), 1040, ["class", "image"])), [
+          [unref(vLoading), { loading: unref(loading), size: "small" }]
+        ]),
+        reProps.value.name ? (openBlock(), createElementBlock("span", {
+          key: 0,
+          class: normalizeClass(`qd-avatar__name ${__props.nameClassName}`)
+        }, toDisplayString(reProps.value.name), 3)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/avatar/props.d.ts

@@ -0,0 +1,7 @@
+export declare const qdAvatarProps: {
+    readonly hideOnLoadFailed: true;
+    readonly mode: "ossId";
+};
+export declare const qdAvatarImageProps: {
+    readonly lazy: true;
+};

package/dist/components/avatar/props.mjs

@@ -0,0 +1,11 @@
+const qdAvatarProps = {
+  hideOnLoadFailed: true,
+  mode: "ossId"
+};
+const qdAvatarImageProps = {
+  lazy: true
+};
+export {
+  qdAvatarImageProps,
+  qdAvatarProps
+};

package/dist/components/avatar/types.d.ts

@@ -0,0 +1,9 @@
+import type { TdAvatarProps } from 'tdesign-vue-next';
+import type { QdAvatarBaseOptions } from '../../hooks/useUserAvatar';
+export interface QdAvatarProps extends Omit<TdAvatarProps, 'image'>, QdAvatarBaseOptions {
+    name?: string;
+    mode?: 'ossId' | 'url';
+    avatarClassName?: string;
+    nameClassName?: string;
+    image?: string | number;
+}

package/dist/components/card/index.css

@@ -0,0 +1,6 @@
+.qd-card[data-v-daddf5e3]:not(.qd-card--radius) {
+  border-radius: 0;
+}
+[data-v-daddf5e3] .qd-card__header--click {
+  cursor: pointer;
+}

package/dist/components/card/index.d.ts

@@ -0,0 +1,2 @@
+export { default as QdCard } from './index.vue';
+export type { QdCardProps } from './types';

package/dist/components/card/index.vue.d.ts

@@ -0,0 +1,16 @@
+import type { QdCardProps } from './types';
+declare var __VLS_12: string | number, __VLS_13: any;
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_12>]?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<QdCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<QdCardProps> & Readonly<{}>, {
+    bordered: boolean;
+    radius: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/card/index.vue.mjs

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

package/dist/components/card/index.vue2.mjs

@@ -0,0 +1,93 @@
+import './index.css'
+import { defineComponent, mergeDefaults, useTemplateRef, computed, onMounted, watch, createBlock, openBlock, unref, mergeProps, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { Card } from "tdesign-vue-next";
+import { qdCardProps } from "./props.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: /* @__PURE__ */ mergeDefaults({
+    radius: { type: Boolean },
+    onHeaderClick: { type: Function },
+    onClick: { type: Function },
+    actions: {},
+    avatar: {},
+    bordered: { type: Boolean },
+    bodyClassName: {},
+    bodyStyle: {},
+    content: {},
+    cover: {},
+    default: {},
+    description: {},
+    footer: {},
+    footerClassName: {},
+    footerStyle: {},
+    header: {},
+    headerClassName: {},
+    headerStyle: {},
+    headerBordered: { type: Boolean },
+    hoverShadow: { type: Boolean },
+    loading: { type: Boolean },
+    loadingProps: {},
+    shadow: { type: Boolean },
+    size: {},
+    status: {},
+    subtitle: {},
+    theme: {},
+    title: {}
+  }, qdCardProps),
+  setup(__props) {
+    const props = __props;
+    const cardRef = useTemplateRef("card");
+    const reProps = computed(() => {
+      const { loadingProps, onHeaderClick, headerClassName, ...otherOptions } = props;
+      let reHeaderClassName = headerClassName;
+      if (onHeaderClick) {
+        reHeaderClassName = reHeaderClassName ? `${reHeaderClassName} qd-card__header--click` : "qd-card__header--click";
+      }
+      return {
+        ...otherOptions,
+        onHeaderClick,
+        headerClassName: reHeaderClassName,
+        loadingProps: {
+          size: "small",
+          ...loadingProps
+        }
+      };
+    });
+    onMounted(() => {
+      watch(
+        () => reProps.value?.onHeaderClick,
+        (newOnHeaderClick, lastOnHeaderClick) => {
+          const headerEl = cardRef.value?.$el?.querySelector(".t-card__header");
+          if (!headerEl) return;
+          if (lastOnHeaderClick) {
+            headerEl.removeEventListener("click", lastOnHeaderClick);
+          }
+          if (newOnHeaderClick) {
+            headerEl.addEventListener("click", newOnHeaderClick);
+          }
+        },
+        { immediate: true }
+      );
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Card), mergeProps({
+        ref: "card",
+        class: ["qd-card", reProps.value.radius ? "qd-card--radius" : ""]
+      }, reProps.value, {
+        onClick: reProps.value.onClick
+      }), createSlots({ _: 2 }, [
+        renderList(_ctx.$slots, (_, name) => {
+          return {
+            name,
+            fn: withCtx((slotProps) => [
+              renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+            ])
+          };
+        })
+      ]), 1040, ["class", "onClick"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/card/props.d.ts

@@ -0,0 +1,4 @@
+export declare const qdCardProps: {
+    bordered: boolean;
+    radius: boolean;
+};

package/dist/components/card/props.mjs

@@ -0,0 +1,7 @@
+const qdCardProps = {
+  bordered: false,
+  radius: true
+};
+export {
+  qdCardProps
+};

package/dist/components/card/types.d.ts

@@ -0,0 +1,6 @@
+import type { TdCardProps } from 'tdesign-vue-next';
+export interface QdCardProps extends TdCardProps {
+    radius?: boolean;
+    onHeaderClick?: (e: MouseEvent) => void;
+    onClick?: (e: MouseEvent) => void;
+}

package/dist/components/codemirror/index.css

@@ -0,0 +1,49 @@
+.qd-codemirror[data-v-efe7dce6] {
+  --cm-color: var(--td-text-color-primary);
+  --cm-border-color: var(--td-border-level-2-color);
+  --cm-bk-color: var(--td-bg-color-specialcomponent);
+  display: block !important;
+  height: 100%;
+  border: 1px solid var(--td-border-level-2-color);
+  border-radius: var(--td-radius-default);
+  overflow: hidden;
+  transition: border cubic-bezier(0.38, 0, 0.24, 1) 0.2s, box-shadow cubic-bezier(0.38, 0, 0.24, 1) 0.2s, background-color cubic-bezier(0.38, 0, 0.24, 1) 0.2s;
+}
+.qd-codemirror[data-v-efe7dce6]:hover {
+  border-color: var(--td-brand-color);
+}
+.qd-codemirror.qd-codemirror--focus[data-v-efe7dce6] {
+  border-color: var(--td-brand-color);
+  box-shadow: 0 0 0 2px var(--td-brand-color-focus);
+}
+.qd-codemirror.qd-codemirror--disabled[data-v-efe7dce6] {
+  color: var(--td-text-color-disabled);
+  background-color: var(--td-bg-color-component-disabled);
+  cursor: not-allowed;
+}
+.qd-codemirror.qd-codemirror--disabled[data-v-efe7dce6] .cm-editor {
+  background-color: transparent;
+}
+.qd-codemirror.qd-codemirror--disabled[data-v-efe7dce6]:hover {
+  border-color: var(--td-border-level-2-color);
+}
+.qd-codemirror[data-v-efe7dce6] .cm-editor {
+  font: var(--td-font-body-medium);
+  height: 100%;
+}
+.qd-codemirror[data-v-efe7dce6] .cm-scroller {
+  line-height: inherit !important;
+}
+.qd-codemirror[data-v-efe7dce6] .cm-content {
+  margin: 0 !important;
+  padding: calc(calc(var(--td-comp-size-m) - var(--td-line-height-body-medium)) / 2) var(--td-comp-paddingLR-s);
+}
+.qd-codemirror[data-v-efe7dce6] .ͼ1 .cm-placeholder {
+  color: var(--td-text-color-placeholder);
+}
+.t-is-error .qd-codemirror[data-v-efe7dce6] {
+  border-color: var(--td-error-color);
+}
+.t-is-error .qd-codemirror--focus[data-v-efe7dce6] {
+  box-shadow: 0 0 0 2px var(--td-error-color-focus);
+}

package/dist/components/codemirror/index.d.ts

@@ -0,0 +1,3 @@
+export { default as QdCodemirror } from './index.vue';
+export { default as QdCodemirrorLanguages } from './languages';
+export type { QdCodemirrorLanguageName, QdCodemirrorProps } from './types';