yc-design-vue 1.0.2 → 1.0.3

package/es/_shared/icons/IconSearch.vue2.js

@@ -1,4 +1,19 @@
-import _sfc_main from "./IconSearch.vue.js";
+import { defineComponent, createBlock, openBlock, normalizeProps, guardReactiveProps, withCtx, createElementVNode } from "vue";
+import YcIcon from "./_Icon.vue2.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "IconSearch",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(YcIcon, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
+        default: withCtx(() => _cache[0] || (_cache[0] = [
+          createElementVNode("path", { d: "M33.072 33.071c6.248-6.248 6.248-16.379 0-22.627-6.249-6.249-16.38-6.249-22.628 0-6.248 6.248-6.248 16.379 0 22.627 6.248 6.248 16.38 6.248 22.628 0Zm0 0 8.485 8.485" }, null, -1)
+        ])),
+        _: 1,
+        __: [0]
+      }, 16);
+    };
+  }
+});
 export {
   _sfc_main as default
 };

package/es/_shared/utils/dom.d.ts

@@ -4,10 +4,10 @@ import { BreakpointName, ResponsiveValue } from '../../Grid';
 export declare const isServerRendering: boolean;
 export declare const querySelector: (selectors: string, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const getElement: (target: string | HTMLElement | undefined, container?: Document | HTMLElement) => HTMLElement | undefined;
-export declare function getDomText(dom: Ref<HTMLElement | undefined>): string;
-export declare function getBreakpointValue(breakpoint: BreakpointName, value: string | number | ResponsiveValue, defaultValue?: number | string): number | string | undefined;
+export declare const getDomText: (dom: Ref<HTMLElement | undefined>) => string;
+export declare const getBreakpointValue: (breakpoint: BreakpointName, value: string | number | ResponsiveValue, defaultValue?: number | string) => number | string | undefined;
 export declare const mediaQueryHandler: (onBreakpoint: (breakpoint: BreakpointName, order: Record<string, number>, index: number) => void, queries?: Record<string, string>) => void;
-export declare function findFirstScrollableParent(element?: HTMLElement): HTMLElement | undefined;
+export declare const findFirstScrollableParent: (element?: HTMLElement) => HTMLElement | undefined;
 /**
  * 计算文本是否需要省略并返回处理后的文本
  * @param originElement 原始DOM元素，用于获取样式
@@ -16,7 +16,7 @@ export declare function findFirstScrollableParent(element?: HTMLElement): HTMLEl
  * @param fullText 完整文本
  * @returns 返回处理后的文本和是否省略的标志
  */
-export declare function calculateEllipsis(originElement: HTMLElement, ellipsisConfig: EllipsisConfig | undefined, operations: (HTMLElement | HTMLElement[] | null) | undefined, fullText: string): {
+export declare const calculateEllipsis: (originElement: HTMLElement, ellipsisConfig: EllipsisConfig | undefined, operations: (HTMLElement | HTMLElement[] | null) | undefined, fullText: string) => {
     tooltip?: {
         type?: "tooltip" | "popover" | undefined;
         props?: Record<string, any> | undefined;

package/es/_shared/utils/dom.js

@@ -21,10 +21,10 @@ const getElement = (target, container) => {
   }
   return target;
 };
-function getDomText(dom) {
+const getDomText = (dom) => {
   var _a;
   return ((_a = unrefElement(dom)) == null ? void 0 : _a.innerText) || "";
-}
+};
 const getMedicaQueryQuerues = () => {
   return {
     xs: "(min-width: 0)",
@@ -35,7 +35,7 @@ const getMedicaQueryQuerues = () => {
     xxl: "(min-width: 1600px)"
   };
 };
-function getBreakpointValue(breakpoint, value, defaultValue) {
+const getBreakpointValue = (breakpoint, value, defaultValue) => {
   if (!isObject(value)) {
     return value;
   }
@@ -52,7 +52,7 @@ function getBreakpointValue(breakpoint, value, defaultValue) {
     return value[bp];
   }
   return defaultValue;
-}
+};
 const mediaQueryHandler = (onBreakpoint, queries = getMedicaQueryQuerues()) => {
   const breakpoints = [];
   const order = {};
@@ -73,7 +73,7 @@ const mediaQueryHandler = (onBreakpoint, queries = getMedicaQueryQuerues()) => {
     }
   );
 };
-function findFirstScrollableParent(element) {
+const findFirstScrollableParent = (element) => {
   if (!element || element === document.body) {
     return;
   }
@@ -88,7 +88,7 @@ function findFirstScrollableParent(element) {
     }
     currentElement = currentElement.parentElement;
   }
-}
+};
 export {
   findFirstScrollableParent,
   getBreakpointValue,

package/es/_shared/utils/fn.d.ts

@@ -1,8 +1,8 @@
 export declare const sleep: (ms: number) => Promise<unknown>;
-export declare function throttleByRaf(cb: (...args: any[]) => void): {
+export declare const throttleByRaf: (cb: (...args: any[]) => void) => {
     (...args: any[]): void;
     cancel(): void;
 };
-export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number, immediate?: boolean): (...args: Parameters<T>) => void;
-export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+export declare const debounce: (func: (...args: any) => void, delay: number, immediate?: boolean) => (this: any, ...args: any) => void;
+export declare const throttle: (fn: (...args: any) => void, delay: number) => (this: any, ...args: any) => void;
 export declare const valueToPx: (value: string | number | undefined) => string;

package/es/_shared/utils/fn.js

@@ -6,7 +6,7 @@ const sleep = (ms) => {
     }, ms);
   });
 };
-function throttleByRaf(cb) {
+const throttleByRaf = (cb) => {
   let timer = 0;
   const throttle2 = (...args) => {
     if (timer) {
@@ -22,8 +22,8 @@ function throttleByRaf(cb) {
     timer = 0;
   };
   return throttle2;
-}
-function debounce(func, delay, immediate = false) {
+};
+const debounce = (func, delay, immediate = false) => {
   let timer = null;
   let isInvoked = false;
   return function(...args) {
@@ -40,8 +40,8 @@ function debounce(func, delay, immediate = false) {
       isInvoked = false;
     }, delay);
   };
-}
-function throttle(fn, delay) {
+};
+const throttle = (fn, delay) => {
   let lastTime = 0;
   let timeoutId = null;
   return function(...args) {
@@ -62,7 +62,7 @@ function throttle(fn, delay) {
       }, remaining);
     }
   };
-}
+};
 const valueToPx = (value) => {
   const numberReg = /^-?\d+(\.\d+)?$/;
   if (isNumber(value) || isString(value) && numberReg.test(value)) {

package/es/_shared/utils/global-config.d.ts

@@ -21,8 +21,10 @@ export declare const getGlobalConfig: (props?: Props) => {
     exchangeTime: Ref<any, any>;
     renderEmpty: (name: EmptyComponent) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
         [key: string]: any;
-    }> | (() => void | undefined);
+    }> | (() => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>[] | undefined);
     renderLoading: () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
         [key: string]: any;
-    }> | (() => void);
+    }> | (() => VNode[]);
 };

package/es/index.d.ts

@@ -678,7 +678,70 @@ declare const _default: {
                 $attrs: {
                     [x: string]: unknown;
                 };
-                $refs: any;
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    triggerRef: unknown;
+                    popupRef: ({
+                        $: import('vue').ComponentInternalInstance;
+                        $data: {};
+                        $props: {
+                            readonly preventFocus?: boolean | undefined;
+                            readonly tag?: string | undefined;
+                        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: import('vue').Slot<any> | undefined;
+                        }>;
+                        $root: import('vue').ComponentPublicInstance | null;
+                        $parent: import('vue').ComponentPublicInstance | null;
+                        $host: Element | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: import('vue').ComponentOptionsBase<Readonly<{
+                            preventFocus?: boolean;
+                            tag?: string;
+                        }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                            preventFocus: boolean;
+                            tag: string;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                            beforeCreate?: (() => void) | (() => void)[];
+                            created?: (() => void) | (() => void)[];
+                            beforeMount?: (() => void) | (() => void)[];
+                            mounted?: (() => void) | (() => void)[];
+                            beforeUpdate?: (() => void) | (() => void)[];
+                            updated?: (() => void) | (() => void)[];
+                            activated?: (() => void) | (() => void)[];
+                            deactivated?: (() => void) | (() => void)[];
+                            beforeDestroy?: (() => void) | (() => void)[];
+                            beforeUnmount?: (() => void) | (() => void)[];
+                            destroyed?: (() => void) | (() => void)[];
+                            unmounted?: (() => void) | (() => void)[];
+                            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof import('vue').nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                    } & Readonly<{
+                        preventFocus: boolean;
+                        tag: string;
+                    }> & Omit<Readonly<{
+                        preventFocus?: boolean;
+                        tag?: string;
+                    }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                        $slots: {
+                            default?(_: {}): any;
+                        };
+                    }) | null;
+                    arrowRef: HTMLDivElement;
+                };
                 $slots: Readonly<{
                     [name: string]: import('vue').Slot<any> | undefined;
                 }>;
@@ -799,7 +862,7 @@ declare const _default: {
                 show(): void;
                 updatePosition(x: number, y: number): void;
             }> & {} & import('vue').ComponentCustomProperties & {} & {
-                $slots: any;
+                $slots: Readonly<import('./Trigger').TriggerSlots> & import('./Trigger').TriggerSlots;
             }) | null;
             optionRef: ({
                 $: import('vue').ComponentInternalInstance;