yc-design-vue 1.0.1

package/es/Drawer/index.js

@@ -0,0 +1,37 @@
+import { h, render } from "vue";
+import _Drawer from "./Drawer.vue.js";
+import _sfc_main from "./DrawerService.vue.js";
+let container;
+const open = (props) => {
+  if (!container) {
+    container = document.createElement("div");
+    container.className = "yc-overlay yc-overlay-drawer";
+    document.body.append(container);
+  }
+  const close = () => {
+    render(null, container);
+  };
+  const update = (updateProps) => {
+    console.log("函数执行了", updateProps);
+  };
+  const vnode = h(_sfc_main, {
+    ...props,
+    serviceClose: close
+  });
+  render(vnode, container);
+  return {
+    close,
+    update
+  };
+};
+const Drawer = Object.assign(_Drawer, {
+  install: (app) => {
+    app.component("Yc" + _Drawer.name, _Drawer);
+    app.config.globalProperties.$drawer = Object.assign(_Drawer, {
+      open
+    });
+  }
+});
+export {
+  Drawer as default
+};

package/es/Drawer/type.d.ts

@@ -0,0 +1,60 @@
+import { CSSProperties } from 'vue';
+import { ButtonProps } from '../Button';
+import { OnBeforeCancel, OnBeforeOk } from '../Modal';
+import { RenderContent, PopupContainer } from '../_shared/type';
+export interface DrawerProps {
+    visible?: boolean;
+    defaultVisible?: boolean;
+    placement?: DrawerPlacement;
+    title?: string;
+    mask?: boolean;
+    maskClosable?: boolean;
+    closable?: boolean;
+    okText?: string;
+    cancelText?: string;
+    okLoading?: boolean;
+    okButtonProps?: ButtonProps;
+    cancelButtonProps?: ButtonProps;
+    unmountOnClose?: boolean;
+    width?: number | string;
+    height?: number | string;
+    popupContainer?: PopupContainer;
+    drawerStyle?: CSSProperties;
+    escToClose?: boolean;
+    renderToBody?: boolean;
+    header?: boolean;
+    footer?: boolean;
+    hideCancel?: boolean;
+    onBeforeCancel?: OnBeforeCancel;
+    onBeforeOk?: OnBeforeOk;
+}
+export interface DrawerSlots {
+    default(): void;
+    header(): void;
+    footer(): void;
+    title(): void;
+}
+export interface DrawerEmits {
+    (e: 'update:visible', value: boolean): void;
+    (e: 'ok'): void;
+    (e: 'cancel', event: MouseEvent | KeyboardEvent): void;
+    (e: 'before-open'): void;
+    (e: 'open'): void;
+    (e: 'before-close'): void;
+    (e: 'close'): void;
+}
+export type DrawerConfig = Omit<DrawerProps, 'visible' | 'defaultVisible'> & {
+    content?: RenderContent;
+    title?: RenderContent;
+    onOk?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onBeforeOpen?: () => void;
+    onBeforeClose?: () => void;
+};
+export declare type DrawerUpdateConfig = Omit<DrawerConfig, 'title' | 'content' | 'onOk' | 'onCancel' | 'onBeforeOk' | 'onBeforeCancel' | 'onOpen' | 'onClose' | 'onBeforeOpen' | 'onBeforeClose' | 'header' | 'footer'>;
+export type DrawerServiceProps = DrawerConfig & {
+    serviceClose?: () => void;
+};
+export type DrawerPlacement = 'right' | 'left' | 'top' | 'bottom';

package/es/Dropdown/Dgroup.vue.d.ts

@@ -0,0 +1,16 @@
+import { DgroupProps, DgroupSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<DgroupSlots> & DgroupSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DgroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DgroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Dropdown/Dgroup.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Dgroup.vue2.js";
+/* empty css            */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const Dgroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2fca632e"]]);
+export {
+  Dgroup as default
+};

package/es/Dropdown/Dgroup.vue2.js

@@ -0,0 +1,26 @@
+import { defineComponent, createElementBlock, openBlock, Fragment, createElementVNode, renderSlot, createTextVNode, toDisplayString } from "vue";
+const _hoisted_1 = { class: "yc-dropdown-group-title text-ellipsis" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Dgroup"
+  },
+  __name: "Dgroup",
+  props: {
+    title: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(_ctx.title), 1)
+          ], true)
+        ]),
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 64);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Dropdown/Doption.vue.d.ts

@@ -0,0 +1,24 @@
+import { DoptionProps, DoptionSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<DoptionSlots> & DoptionSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DoptionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (ev: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DoptionProps> & Readonly<{
+    onClick?: ((ev: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    isSubmenu: boolean;
+    isActive: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Dropdown/Doption.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Doption.vue2.js";
+/* empty css             */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const Doption = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-05a4bb68"]]);
+export {
+  Doption as default
+};

package/es/Dropdown/Doption.vue2.js

@@ -0,0 +1,63 @@
+import { defineComponent, toRefs, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createElementVNode, renderSlot } from "vue";
+import useContext from "./hooks/useContext.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "yc-dropdown-option-icon"
+};
+const _hoisted_2 = { class: "yc-dropdown-option-content text-ellipsis" };
+const _hoisted_3 = {
+  key: 1,
+  class: "yc-dropdown-option-suffix"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Doption"
+  },
+  __name: "Doption",
+  props: {
+    value: { type: [String, Number, Boolean, Object] },
+    disabled: { type: Boolean, default: false },
+    isSubmenu: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: false }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { value: optionValue, disabled, isSubmenu } = toRefs(props);
+    const { select, theme } = useContext().inject();
+    const handleClick = (ev) => {
+      if (disabled.value) return;
+      emits("click", ev);
+      if (isSubmenu.value) return;
+      select(optionValue.value, ev);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-dropdown-option",
+          `yc-dropdown-option-theme-${unref(theme)}`,
+          {
+            "yc-dropdown-option-active": _ctx.isActive,
+            "yc-dropdown-option-disabled": unref(disabled),
+            "yc-dropdown-option-has-suffix": _ctx.$slots.suffix
+          }
+        ]),
+        onClick: handleClick
+      }, [
+        _ctx.$slots.icon ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "icon", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _ctx.$slots.suffix ? (openBlock(), createElementBlock("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "suffix", {}, void 0, true)
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Dropdown/Dropdown.vue.d.ts

@@ -0,0 +1,38 @@
+import { DropdownProps, DoptionValue, DropdownSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<DropdownSlots> & DropdownSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DropdownProps, {
+    show(): void;
+    hide(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:popupVisible": (value: boolean) => any;
+    "popup-visible-change": (value: boolean) => any;
+    select: (value: DoptionValue, ev: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DropdownProps> & Readonly<{
+    "onUpdate:popupVisible"?: ((value: boolean) => any) | undefined;
+    "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+    onSelect?: ((value: DoptionValue, ev: MouseEvent) => any) | undefined;
+}>, {
+    trigger: import('../Trigger').TriggerType;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    alignPoint: boolean;
+    position: import('./type').DropdownPosition;
+    popupContainer: import('..').PopupContainer;
+    triggerProps: import('../Trigger').TriggerProps;
+    hideOnSelect: boolean;
+    theme: import('..').Theme;
+    popupMaxHeight: number | boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Dropdown/Dropdown.vue.js

@@ -0,0 +1,111 @@
+import { defineComponent, toRefs, computed, createBlock, openBlock, unref, mergeProps, isRef, withCtx, renderSlot, createElementVNode, createVNode, createElementBlock, createCommentVNode, normalizeStyle } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { valueToPx } from "../_shared/utils/fn.js";
+import { isBoolean, isUndefined } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+import Trigger from "../Trigger/index.js";
+import Scrollbar from "../Scrollbar/index.js";
+const _hoisted_1 = { class: "yc-dropdown" };
+const _hoisted_2 = { class: "yc-dropdown-list" };
+const _hoisted_3 = {
+  key: 0,
+  class: "yc-dropdown-footer"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Dropdown"
+  },
+  __name: "Dropdown",
+  props: {
+    popupVisible: { type: Boolean, default: void 0 },
+    defaultPopupVisible: { type: Boolean, default: false },
+    trigger: { default: "click" },
+    position: { default: "bottom" },
+    popupContainer: { default: void 0 },
+    hideOnSelect: { type: Boolean, default: true },
+    alignPoint: { type: Boolean, default: false },
+    triggerProps: { default: () => {
+      return {};
+    } },
+    popupMaxHeight: { type: [Number, Boolean], default: 200 },
+    theme: { default: "light" }
+  },
+  emits: ["update:popupVisible", "popup-visible-change", "select"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      trigger,
+      position: _position,
+      popupMaxHeight: _popupMaxHeight
+    } = toRefs(props);
+    const { computedVisible } = useContext().provide(props, emits);
+    const position = computed(() => {
+      return ["top", "tl", "tr", "bottom", "bl", "br"].includes(_position.value) ? _position.value : "bottom";
+    });
+    const popupMaxHeight = computed(() => {
+      if (isBoolean(_popupMaxHeight.value) && !_popupMaxHeight.value || isUndefined(_popupMaxHeight)) {
+        return "";
+      }
+      return valueToPx(
+        isBoolean(_popupMaxHeight.value) ? 200 : _popupMaxHeight.value
+      );
+    });
+    __expose({
+      show() {
+        computedVisible.value = true;
+      },
+      hide() {
+        computedVisible.value = true;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Trigger), mergeProps({
+        "popup-visible": unref(computedVisible),
+        "onUpdate:popupVisible": _cache[0] || (_cache[0] = ($event) => isRef(computedVisible) ? computedVisible.value = $event : null),
+        trigger: unref(trigger),
+        position: position.value,
+        "popup-offset": 4,
+        "mouse-enter-delay": 150,
+        "mouse-leave-delay": 150,
+        alignPoint: _ctx.alignPoint,
+        "auto-fit-popup-min-width": !_ctx.alignPoint && ["top", "bottom"].includes(position.value),
+        class: ["yc-dropdown-popup", , `yc-dropdown-theme-${_ctx.theme}`, _ctx.$attrs.class],
+        style: _ctx.$attrs.style,
+        "animation-name": "slide-dynamic-origin",
+        "need-transform-origin": ""
+      }, _ctx.triggerProps), {
+        content: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            createVNode(unref(Scrollbar), {
+              style: normalizeStyle({
+                maxHeight: popupMaxHeight.value
+              })
+            }, {
+              default: withCtx(() => [
+                createElementVNode("div", _hoisted_2, [
+                  renderSlot(_ctx.$slots, "content")
+                ])
+              ]),
+              _: 3
+            }, 8, ["style"]),
+            _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_3, [
+              renderSlot(_ctx.$slots, "footer")
+            ])) : createCommentVNode("", true)
+          ])
+        ]),
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["popup-visible", "trigger", "position", "alignPoint", "auto-fit-popup-min-width", "class", "style"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Dropdown/Dropdown.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./Dropdown.vue.js";
+/* empty css              */
+export {
+  _sfc_main as default
+};

package/es/Dropdown/DropdownButton.vue.d.ts

@@ -0,0 +1,35 @@
+import { DropdownButtonProps, DoptionValue, DropdownButtonSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<DropdownButtonSlots> & DropdownButtonSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DropdownButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (ev: MouseEvent) => any;
+    "popup-visible-change": (value: boolean) => any;
+    select: (value: DoptionValue) => any;
+}, string, import('vue').PublicProps, Readonly<DropdownButtonProps> & Readonly<{
+    onClick?: ((ev: MouseEvent) => any) | undefined;
+    "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+    onSelect?: ((value: DoptionValue) => any) | undefined;
+}>, {
+    size: import('..').Size;
+    trigger: import('..').TriggerType;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    disabled: boolean;
+    position: import('./type').DropdownPosition;
+    popupContainer: import('..').PopupContainer;
+    type: import('../Button').ButtonType;
+    hideOnSelect: boolean;
+    buttonProps: import('../Button').ButtonProps;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Dropdown/DropdownButton.vue.js

@@ -0,0 +1,84 @@
+import { defineComponent, createBlock, openBlock, unref, withCtx, createVNode, mergeProps, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import _sfc_main$3 from "../_shared/icons/IconMore.vue.js";
+import _sfc_main$2 from "./Dropdown.vue.js";
+/* empty css              */
+import Button from "../Button/index.js";
+import _sfc_main$1 from "../Button/ButtonGroup.vue.js";
+/* empty css                         */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "DropdownButton"
+  },
+  __name: "DropdownButton",
+  props: {
+    popupVisible: { type: Boolean, default: void 0 },
+    defaultPopupVisible: { type: Boolean, default: false },
+    trigger: { default: "click" },
+    position: { default: "br" },
+    popupContainer: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    type: { default: "secondary" },
+    size: { default: void 0 },
+    buttonProps: { default: () => {
+      return {};
+    } },
+    hideOnSelect: { type: Boolean, default: true }
+  },
+  emits: ["popup-visible-change", "click", "select"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), {
+        disabled: _ctx.disabled,
+        type: _ctx.type,
+        size: _ctx.size
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(Button), mergeProps(_ctx.buttonProps, {
+            onClick: _cache[0] || (_cache[0] = (ev) => _ctx.$emit("click", ev))
+          }), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 16),
+          createVNode(_sfc_main$2, mergeProps({
+            "popup-visible": _ctx.popupVisible,
+            "default-popup-visible": _ctx.defaultPopupVisible,
+            trigger: _ctx.trigger,
+            position: _ctx.position,
+            "popup-container": _ctx.popupContainer,
+            "hide-on-select": _ctx.hideOnSelect,
+            disabled: _ctx.disabled
+          }, _ctx.$attrs, {
+            onSelect: _cache[1] || (_cache[1] = (v) => _ctx.$emit("select", v)),
+            onPopupVisibleChange: _cache[2] || (_cache[2] = (v) => _ctx.$emit("popup-visible-change", v))
+          }), {
+            content: withCtx(() => [
+              renderSlot(_ctx.$slots, "content")
+            ]),
+            default: withCtx(() => [
+              createVNode(unref(Button), normalizeProps(guardReactiveProps(_ctx.buttonProps)), {
+                icon: withCtx(() => [
+                  renderSlot(_ctx.$slots, "icon", {}, () => [
+                    createVNode(unref(_sfc_main$3))
+                  ])
+                ]),
+                _: 3
+              }, 16)
+            ]),
+            _: 3
+          }, 16, ["popup-visible", "default-popup-visible", "trigger", "position", "popup-container", "hide-on-select", "disabled"])
+        ]),
+        _: 3
+      }, 8, ["disabled", "type", "size"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Dropdown/DropdownButton.vue2.js

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