yc-design-vue 1.0.1

package/es/Button/ButtonGroup.vue.js

@@ -0,0 +1,33 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
+import useContext from "./hooks/useContext.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "ButtonGroup"
+  },
+  __name: "ButtonGroup",
+  props: {
+    type: { default: "secondary" },
+    status: { default: "normal" },
+    shape: { default: "square" },
+    size: { default: void 0 },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    useContext().provide(props);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-button-group",
+          `yc-button-group-${_ctx.type}`,
+          `yc-button-group-status-${_ctx.status}`
+        ])
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Button/ButtonGroup.vue3.js

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

package/es/Button/hooks/useContext.d.ts

@@ -0,0 +1,13 @@
+import { ButtonType, ButtonShape, ButtonStatus } from '../type';
+import { Props } from '../../_shared/type';
+declare const _default: () => {
+    provide: (props: Props) => void;
+    inject: (props: Props) => {
+        disabled: import('vue').ComputedRef<boolean>;
+        type: import('vue').ComputedRef<ButtonType>;
+        status: import('vue').ComputedRef<ButtonStatus>;
+        shape: import('vue').ComputedRef<ButtonShape>;
+        size: import('vue').ComputedRef<boolean | "mini" | "small" | "medium" | "large" | "normal" | "round" | "dashed" | "text" | "circle" | "square" | "primary" | "secondary" | "success" | "danger" | "warning" | "outline" | undefined>;
+    };
+};
+export default _default;

package/es/Button/hooks/useContext.js

@@ -0,0 +1,63 @@
+import { toRefs, provide, inject, ref, computed } from "vue";
+import "../../node_modules/tinycolor2/esm/tinycolor.js";
+import "../../_shared/utils/dom.js";
+import { isUndefined } from "../../_shared/utils/is.js";
+import "../../_shared/utils/time.js";
+import { getGlobalConfig } from "../../_shared/utils/global-config.js";
+const BUTTON_GROUP_CONTEXT_KEY = "button-group-context";
+const useContext = () => {
+  const provide$1 = (props) => {
+    const { type, status, shape, disabled } = toRefs(props);
+    const { size } = getGlobalConfig(props);
+    provide(BUTTON_GROUP_CONTEXT_KEY, {
+      type,
+      status,
+      size,
+      shape,
+      disabled
+    });
+  };
+  const inject$1 = (props) => {
+    const { size: globalSize } = getGlobalConfig(props);
+    const { type, status, shape, size, disabled } = toRefs(
+      props
+    );
+    const {
+      type: _type,
+      status: _status,
+      shape: _shape,
+      disabled: _disabled,
+      size: _size
+    } = inject(BUTTON_GROUP_CONTEXT_KEY, {
+      type: ref("secondary"),
+      status: ref("normal"),
+      shape: ref("square"),
+      disabled: ref(false)
+    });
+    const getField = (value, injectValue, globalValue) => {
+      if (!isUndefined(value)) {
+        return value;
+      }
+      if (isUndefined(globalValue)) {
+        return injectValue;
+      }
+      return !isUndefined(injectValue) ? injectValue : globalValue;
+    };
+    return {
+      disabled: computed(() => disabled.value ?? _disabled.value),
+      type: computed(() => type.value ?? _type.value),
+      status: computed(() => status.value ?? _status.value),
+      shape: computed(() => shape.value ?? _shape.value),
+      size: computed(
+        () => getField(size.value, _size == null ? void 0 : _size.value, globalSize.value)
+      )
+    };
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  useContext as default
+};

package/es/Button/index.d.ts

@@ -0,0 +1,124 @@
+import { App } from 'vue';
+import { default as _Button } from './Button.vue';
+import { default as _ButtonGroup } from './ButtonGroup.vue';
+export type ButonInstance = InstanceType<typeof _Button>;
+export type ButonGroupInstance = InstanceType<typeof _ButtonGroup>;
+export * from './type';
+declare const Button: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').ButtonProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onContextmenu?: ((event: MouseEvent) => any) | undefined;
+        onDblclick?: ((event: MouseEvent) => any) | undefined;
+        onMousedown?: ((event: MouseEvent) => any) | undefined;
+        onMouseup?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        click: (event: MouseEvent) => any;
+        contextmenu: (event: MouseEvent) => any;
+        dblclick: (event: MouseEvent) => any;
+        mousedown: (event: MouseEvent) => any;
+        mouseup: (event: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').Size;
+        disabled: boolean;
+        loading: boolean;
+        type: import('./type').ButtonType;
+        href: string;
+        shape: import('./type').ButtonShape;
+        status: import('./type').ButtonStatus;
+        long: boolean;
+        htmlType: import('./type').ButtonHtmlType;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').ButtonProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onContextmenu?: ((event: MouseEvent) => any) | undefined;
+        onDblclick?: ((event: MouseEvent) => any) | undefined;
+        onMousedown?: ((event: MouseEvent) => any) | undefined;
+        onMouseup?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('..').Size;
+        disabled: boolean;
+        loading: boolean;
+        type: import('./type').ButtonType;
+        href: string;
+        shape: import('./type').ButtonShape;
+        status: import('./type').ButtonStatus;
+        long: boolean;
+        htmlType: import('./type').ButtonHtmlType;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').ButtonProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onContextmenu?: ((event: MouseEvent) => any) | undefined;
+    onDblclick?: ((event: MouseEvent) => any) | undefined;
+    onMousedown?: ((event: MouseEvent) => any) | undefined;
+    onMouseup?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+    contextmenu: (event: MouseEvent) => any;
+    dblclick: (event: MouseEvent) => any;
+    mousedown: (event: MouseEvent) => any;
+    mouseup: (event: MouseEvent) => any;
+}, string, {
+    size: import('..').Size;
+    disabled: boolean;
+    loading: boolean;
+    type: import('./type').ButtonType;
+    href: string;
+    shape: import('./type').ButtonShape;
+    status: import('./type').ButtonStatus;
+    long: boolean;
+    htmlType: import('./type').ButtonHtmlType;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').ButtonSlots> & import('./type').ButtonSlots;
+}) & {
+    group: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            size: import('..').Size;
+            disabled: boolean;
+            type: import('./type').ButtonType;
+            shape: import('./type').ButtonShape;
+            status: import('./type').ButtonStatus;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+            size: import('..').Size;
+            disabled: boolean;
+            type: import('./type').ButtonType;
+            shape: import('./type').ButtonShape;
+            status: import('./type').ButtonStatus;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        size: import('..').Size;
+        disabled: boolean;
+        type: import('./type').ButtonType;
+        shape: import('./type').ButtonShape;
+        status: import('./type').ButtonStatus;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').ButtonGroupSlots> & import('./type').ButtonGroupSlots;
+    });
+    install: (app: App) => void;
+};
+export { _ButtonGroup as ButtonGroup };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcButton: typeof Button;
+        YcButtonGroup: typeof _ButtonGroup;
+    }
+}
+export default Button;

package/es/Button/index.js

@@ -0,0 +1,14 @@
+import _Button from "./Button.vue.js";
+import _sfc_main from "./ButtonGroup.vue.js";
+/* empty css                 */
+const Button = Object.assign(_Button, {
+  group: _sfc_main,
+  install: (app) => {
+    app.component("Yc" + _Button.name, _Button);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
+  }
+});
+export {
+  _sfc_main as ButtonGroup,
+  Button as default
+};

package/es/Button/type.d.ts

@@ -0,0 +1,37 @@
+import { Size } from '../_shared/type';
+export interface ButtonProps {
+    type?: ButtonType;
+    shape?: ButtonShape;
+    status?: ButtonStatus;
+    size?: Size;
+    long?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    htmlType?: ButtonHtmlType;
+    href?: string;
+}
+export interface ButtonEmits {
+    (e: 'mousedown', event: MouseEvent): void;
+    (e: 'mouseup', event: MouseEvent): void;
+    (e: 'click', event: MouseEvent): void;
+    (e: 'dblclick', event: MouseEvent): void;
+    (e: 'contextmenu', event: MouseEvent): void;
+}
+export interface ButtonSlots {
+    default(): void;
+    icon(): void;
+}
+export interface ButtonGroupProps {
+    type?: ButtonType;
+    status?: ButtonStatus;
+    shape?: ButtonShape;
+    size?: Size;
+    disabled?: boolean;
+}
+export interface ButtonGroupSlots {
+    default(): void;
+}
+export type ButtonStatus = 'normal' | 'warning' | 'success' | 'danger';
+export type ButtonShape = 'square' | 'circle' | 'round';
+export type ButtonType = 'primary' | 'secondary' | 'dashed' | 'outline' | 'text';
+export type ButtonHtmlType = 'button' | 'reset' | 'submit';

package/es/Calendar/Calendar.vue.d.ts

@@ -0,0 +1,32 @@
+import { CalendarProps, CalendarSlots, CalendarMode } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CalendarSlots> & CalendarSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CalendarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: Date) => any;
+    "update:modelValue": (value: Date) => any;
+    "update:mode": (mode: CalendarMode) => any;
+    "panel-change": (value: Date) => any;
+}, string, import('vue').PublicProps, Readonly<CalendarProps> & Readonly<{
+    onChange?: ((value: Date) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+    "onUpdate:mode"?: ((mode: CalendarMode) => any) | undefined;
+    "onPanel-change"?: ((value: Date) => any) | undefined;
+}>, {
+    mode: CalendarMode;
+    modelValue: Date;
+    defaultValue: Date;
+    defaultMode: CalendarMode;
+    modes: CalendarMode[];
+}, {}, {}, {}, 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/Calendar/Calendar.vue.js

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

package/es/Calendar/Calendar.vue2.js

@@ -0,0 +1,208 @@
+import { defineComponent, toRefs, ref, watch, computed, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, createVNode, withCtx, renderSlot, createTextVNode, toDisplayString, isRef, createBlock, createSlots, normalizeProps, guardReactiveProps } from "vue";
+import dayjs from "../node_modules/dayjs/dayjs.min.js";
+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$1 from "../_shared/icons/IconArrowRight.vue.js";
+import useControlValue from "../_shared/utils/control.js";
+import IconButton from "../_shared/components/IconButton.vue.js";
+/* empty css                                         */
+import Button from "../Button/index.js";
+import "../Radio/index.js";
+import MonthCalendar from "./CalendarMonth.vue.js";
+import YearCalendar from "./CalendarYear.vue.js";
+import _sfc_main$2 from "../Radio/RadioGroup.vue.js";
+/* empty css                       */
+const _hoisted_1 = { class: "yc-calendar-header" };
+const _hoisted_2 = { class: "yc-calendar-header-left" };
+const _hoisted_3 = { class: "yc-calendar-header-value" };
+const _hoisted_4 = { class: "yc-calendar-header-right" };
+const _hoisted_5 = { class: "yc-calendar-body" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Calendar"
+  },
+  __name: "Calendar",
+  props: {
+    modelValue: { default: void 0 },
+    defaultValue: { default: () => /* @__PURE__ */ new Date() },
+    mode: { default: void 0 },
+    defaultMode: { default: "month" },
+    modes: { default: () => ["month", "year"] }
+  },
+  emits: ["update:modelValue", "update:mode", "change", "panel-change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultValue,
+      mode,
+      defaultMode,
+      modes: _modes
+    } = toRefs(props);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits("update:modelValue", val);
+        emits("change", val);
+      }
+    );
+    const recordDate = ref({});
+    watch(
+      () => computedValue.value,
+      (val) => {
+        const date = val ? dayjs(val) : dayjs();
+        recordDate.value = {
+          year: date.year(),
+          month: date.month() + 1,
+          day: date.date()
+        };
+      },
+      {
+        immediate: true
+      }
+    );
+    const computedMode = useControlValue(
+      mode,
+      defaultMode.value,
+      (val) => {
+        emits("update:mode", val);
+        emits("panel-change", computedValue.value);
+      }
+    );
+    const modes = computed(() => {
+      const map = {
+        month: "月",
+        year: "年"
+      };
+      return _modes.value.map((item) => {
+        return {
+          label: map[item],
+          value: item
+        };
+      });
+    });
+    const handleClick = (col) => {
+      computedValue.value = new Date(col.fullDate);
+    };
+    const handleDateChange = (type) => {
+      if (type == "today") {
+        computedValue.value = /* @__PURE__ */ new Date();
+        return;
+      }
+      const { year, month } = recordDate.value;
+      if (type == "next") {
+        const tempMonth = month + 1 > 12 ? 1 : month + 1;
+        const tempYear = month + 1 > 12 || computedMode.value == "year" ? 1 : 0;
+        recordDate.value.year = year + tempYear;
+        if (computedMode.value == "year") return;
+        recordDate.value.month = tempMonth;
+      } else {
+        const tempMonth = month - 1 < 1 ? 12 : month - 1;
+        const tempYear = month - 1 < 1 || computedMode.value == "year" ? -1 : 0;
+        recordDate.value.year = year + tempYear;
+        if (computedMode.value == "year") return;
+        recordDate.value.month = tempMonth;
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["yc-calendar", `yc-calendar-mode-${unref(computedMode)}`])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", _hoisted_2, [
+            createVNode(unref(IconButton), {
+              class: "yc-calendar-header-icon",
+              role: "button",
+              tabindex: "0",
+              size: 28,
+              "hover-size": 28,
+              onClick: _cache[0] || (_cache[0] = ($event) => handleDateChange("pre"))
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(_sfc_main$1), { rotate: 180 })
+              ]),
+              _: 1
+            }),
+            createElementVNode("div", _hoisted_3, [
+              renderSlot(_ctx.$slots, "header", {
+                year: recordDate.value.year,
+                month: recordDate.value.month
+              }, () => [
+                createTextVNode(toDisplayString(recordDate.value.year) + " 年 " + toDisplayString(recordDate.value.month) + " 月 ", 1)
+              ], true)
+            ]),
+            createVNode(unref(IconButton), {
+              role: "button",
+              tabindex: "0",
+              class: "yc-calendar-header-icon",
+              size: 28,
+              "hover-size": 28,
+              onClick: _cache[1] || (_cache[1] = ($event) => handleDateChange("next"))
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(_sfc_main$1))
+              ]),
+              _: 1
+            }),
+            createVNode(unref(Button), {
+              onClick: _cache[2] || (_cache[2] = ($event) => handleDateChange("today")),
+              size: "small"
+            }, {
+              default: withCtx(() => _cache[4] || (_cache[4] = [
+                createTextVNode(" 今天 ", -1)
+              ])),
+              _: 1,
+              __: [4]
+            })
+          ]),
+          createElementVNode("div", _hoisted_4, [
+            createVNode(unref(_sfc_main$2), {
+              modelValue: unref(computedMode),
+              "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => isRef(computedMode) ? computedMode.value = $event : null),
+              options: modes.value,
+              type: "button",
+              size: "small"
+            }, null, 8, ["modelValue", "options"])
+          ])
+        ]),
+        createElementVNode("div", _hoisted_5, [
+          unref(computedMode) == "month" ? (openBlock(), createBlock(MonthCalendar, {
+            key: 0,
+            "computed-value": unref(computedValue),
+            recordDate: recordDate.value,
+            onCellClick: handleClick
+          }, createSlots({ _: 2 }, [
+            _ctx.$slots.default ? {
+              name: "default",
+              fn: withCtx((scope) => [
+                renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(scope)), void 0, true)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["computed-value", "recordDate"])) : (openBlock(), createBlock(YearCalendar, {
+            key: 1,
+            "computed-value": unref(computedValue),
+            "record-date": recordDate.value,
+            onCellClick: handleClick
+          }, createSlots({ _: 2 }, [
+            _ctx.$slots.default ? {
+              name: "default",
+              fn: withCtx((scope) => [
+                renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(scope)), void 0, true)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["computed-value", "record-date"]))
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Calendar/CalendarMonth.vue.d.ts

@@ -0,0 +1,35 @@
+import { CalendarCellData } from '../_shared/utils';
+type __VLS_Props = {
+    computedValue: Date;
+    recordDate: Record<string, number>;
+    calendar?: CalendarCellData[][];
+    small?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            year: any;
+            month: any;
+            day: any;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "cell-click": (col: CalendarCellData) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onCell-click"?: ((col: CalendarCellData) => any) | undefined;
+}>, {
+    small: boolean;
+    calendar: CalendarCellData[][];
+}, {}, {}, {}, 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/Calendar/CalendarMonth.vue.js

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