@wfrog/vc-ui 1.0.0

package/dist/es/components/image/image.vue.d.ts

@@ -0,0 +1,206 @@
+import { IImageProps } from './image';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        textWrapperRef: HTMLDivElement;
+        textRef: HTMLSpanElement;
+        comEllipsis: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly type?: "single" | undefined;
+                readonly effect?: import('element-plus').PopperEffect | undefined;
+                readonly placement?: Placement;
+                readonly content?: string | undefined;
+                readonly popperOptions?: object | undefined;
+                readonly popperClass?: string | undefined;
+                readonly enterable?: boolean | undefined;
+                readonly maxWidth?: number | undefined;
+                readonly showTooltip?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                mainRef: HTMLDivElement;
+                ellipsisRef: HTMLDivElement;
+                textRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: globalThis.Slot | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../text-ellipsis/text-ellipsis').ITextEllipsisProps> & Readonly<{}>, {
+                tipsVisible: globalThis.Ref<boolean, boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                type: "single";
+                effect: import('element-plus').PopperEffect;
+                popperClass: string;
+                popperOptions: object;
+                placement: Placement;
+                content: string;
+                enterable: boolean;
+                maxWidth: number;
+                showTooltip: boolean;
+            }, {}, 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: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: 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<{
+            type: "single";
+            effect: import('element-plus').PopperEffect;
+            popperClass: string;
+            popperOptions: object;
+            placement: Placement;
+            content: string;
+            enterable: boolean;
+            maxWidth: number;
+            showTooltip: boolean;
+        }> & Omit<Readonly<import('../text-ellipsis/text-ellipsis').ITextEllipsisProps> & Readonly<{}>, "tipsVisible" | ("type" | "effect" | "popperClass" | "popperOptions" | "placement" | "content" | "enterable" | "maxWidth" | "showTooltip")> & import('vue').ShallowUnwrapRef<{
+            tipsVisible: globalThis.Ref<boolean, boolean>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<IImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IImageProps> & Readonly<{}>, {
+    type: "image" | "text";
+    text: string;
+    effect: import('element-plus').PopperEffect;
+    width: string;
+    popperClass: string;
+    height: string;
+    placement: Placement;
+    src: string;
+    fit: IGlobal.ImageFit;
+    previewSrcList: string[];
+    enterable: boolean;
+    showTooltip: boolean;
+    textMaxWidth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    textWrapperRef: HTMLDivElement;
+    textRef: HTMLSpanElement;
+    comEllipsis: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly type?: "single" | undefined;
+            readonly effect?: import('element-plus').PopperEffect | undefined;
+            readonly placement?: Placement;
+            readonly content?: string | undefined;
+            readonly popperOptions?: object | undefined;
+            readonly popperClass?: string | undefined;
+            readonly enterable?: boolean | undefined;
+            readonly maxWidth?: number | undefined;
+            readonly showTooltip?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            mainRef: HTMLDivElement;
+            ellipsisRef: HTMLDivElement;
+            textRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: globalThis.Slot | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../text-ellipsis/text-ellipsis').ITextEllipsisProps> & Readonly<{}>, {
+            tipsVisible: globalThis.Ref<boolean, boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            type: "single";
+            effect: import('element-plus').PopperEffect;
+            popperClass: string;
+            popperOptions: object;
+            placement: Placement;
+            content: string;
+            enterable: boolean;
+            maxWidth: number;
+            showTooltip: boolean;
+        }, {}, 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: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: 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<{
+        type: "single";
+        effect: import('element-plus').PopperEffect;
+        popperClass: string;
+        popperOptions: object;
+        placement: Placement;
+        content: string;
+        enterable: boolean;
+        maxWidth: number;
+        showTooltip: boolean;
+    }> & Omit<Readonly<import('../text-ellipsis/text-ellipsis').ITextEllipsisProps> & Readonly<{}>, "tipsVisible" | ("type" | "effect" | "popperClass" | "popperOptions" | "placement" | "content" | "enterable" | "maxWidth" | "showTooltip")> & import('vue').ShallowUnwrapRef<{
+        tipsVisible: globalThis.Ref<boolean, boolean>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+            default?(_: {}): any;
+            default?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null;
+}, 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/dist/es/components/image/index.css

@@ -0,0 +1,20 @@
+/* source: src/components/image/image.vue */
+._text-wrapper_1toev_1 {
+  position: relative;
+}
+._text-wrapper_1toev_1 ._image_1toev_4 {
+  position: absolute;
+}
+._text-wrapper_1toev_1 ._text_1toev_1 {
+  display: flex;
+  align-items: center;
+  pointer-events: none;
+}
+._text-wrapper_1toev_1 ._icon_1toev_12 {
+  margin-right: 8px;
+  transform: scale(1.3);
+  transform-origin: left center;
+}
+._image-wrapper_1toev_18 {
+  vertical-align: middle;
+}

package/dist/es/components/image/index.d.ts

@@ -0,0 +1,4 @@
+import { SFCWithInstall } from '../../utils/typescript';
+import { default as Component } from './image.vue';
+export declare const VcImage: SFCWithInstall<typeof Component>;
+export default VcImage;

package/dist/es/components/image/index.mjs

@@ -0,0 +1,6 @@
+import { w as withInstall } from '../../chunk/ClZGuAIb.mjs';
+import { C as Component } from './image.mjs';
+
+const VcImage = withInstall(Component);
+
+export { VcImage, VcImage as default };

package/dist/es/components/input/index.css

@@ -0,0 +1,9 @@
+/* source: src/components/input/input.vue */
+div._input_youbd_1 {
+  width: unset;
+  min-width: var(--v5d522f0a);
+}
+div._input_youbd_1._block_youbd_5 {
+  display: flex;
+  width: var(--v5d522f0a);
+}

package/dist/es/components/input/index.d.ts

@@ -0,0 +1,4 @@
+import { SFCWithInstall } from '../../utils/typescript';
+import { default as Component } from './input.vue';
+export declare const VcInput: SFCWithInstall<typeof Component>;
+export default VcInput;

package/dist/es/components/input/index.mjs

@@ -0,0 +1,6 @@
+import { w as withInstall } from '../../chunk/ClZGuAIb.mjs';
+import { C as Component } from './input.mjs';
+
+const VcInput = withInstall(Component);
+
+export { VcInput, VcInput as default };

package/dist/es/components/input/input.d.ts

@@ -0,0 +1,4 @@
+export interface IInputProps {
+    block?: boolean;
+    width?: string;
+}

package/dist/es/components/input/input.mjs

@@ -0,0 +1,85 @@
+import './index.css'
+import '../../chunk/E_WRn0OP.mjs';
+import { E as ElInput } from '../../chunk/Dvi7RsXg.mjs';
+import { defineComponent, useCssVars, unref, computed, useCssModule, useTemplateRef, createBlock, openBlock, normalizeClass, createSlots, withCtx, renderSlot } from 'vue';
+import { _ as _export_sfc } from '../../chunk/pcqpp-6-.mjs';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "input",
+  props: {
+    block: { type: Boolean, default: false },
+    width: {}
+  },
+  setup(__props, { expose: __expose }) {
+    useCssVars((_ctx) => ({
+      "v5d522f0a": unref(myWidth)
+    }));
+    const props = __props;
+    const $style = useCssModule();
+    const inputRef = useTemplateRef("inputRef");
+    const className = computed(() => ({
+      [$style.input]: true,
+      [$style.block]: props.block
+    }));
+    const myWidth = computed(() => {
+      return props.width || (props.block ? "100%" : "240px");
+    });
+    __expose({ inputRef });
+    return (_ctx, _cache) => {
+      const _component_ElInput = ElInput;
+      return openBlock(), createBlock(_component_ElInput, {
+        ref_key: "inputRef",
+        ref: inputRef,
+        class: normalizeClass(unref(className))
+      }, createSlots({ _: 2 }, [
+        _ctx.$slots.prefix ? {
+          name: "prefix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prefix")
+          ]),
+          key: "0"
+        } : void 0,
+        _ctx.$slots.suffix ? {
+          name: "suffix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "suffix")
+          ]),
+          key: "1"
+        } : void 0,
+        _ctx.$slots.prepend ? {
+          name: "prepend",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prepend")
+          ]),
+          key: "2"
+        } : void 0,
+        _ctx.$slots.append ? {
+          name: "append",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "append")
+          ]),
+          key: "3"
+        } : void 0
+      ]), 1032, ["class"]);
+    };
+  }
+});
+
+/* unplugin-vue-components disabled */const input = "_input_youbd_1";
+const block = "_block_youbd_5";
+const style0 = {
+	input: input,
+	block: block
+};
+
+const cssModules = {
+  "$style": style0
+};
+const Component = /* @__PURE__ */ _export_sfc(_sfc_main, [["__cssModules", cssModules]]);
+
+const __vite_glob_0_21 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: Component
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { Component as C, __vite_glob_0_21 as _ };