@pungfe/element 0.0.1-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pengfeng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @pungfe/element

package/dist/basic/XButton.vue.d.ts

@@ -0,0 +1,26 @@
+import { ButtonProps } from 'element-plus';
+export interface XButtonProps extends Partial<ButtonProps> {
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (e: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<XButtonProps> & Readonly<{
+    onClick?: ((e: MouseEvent) => any) | undefined;
+}>, {
+    readonly disabled: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, {}, {}, 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/dist/basic/XCascader.vue.d.ts

@@ -0,0 +1,26 @@
+import { CascaderProps } from 'element-plus';
+export interface XCascaderProps {
+    clearable?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    props?: CascaderProps;
+}
+declare const _default: <D, V extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        readonly onBlur?: (() => any) | undefined;
+        readonly onChange?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange"> & ({
+        modelValue?: V;
+    } & XCascaderProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "blur") => void) & ((evt: "change", value: V) => void)) & ((evt: "update:modelValue", value: V) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XCheckbox.vue.d.ts

@@ -0,0 +1,28 @@
+import { CheckboxProps } from 'element-plus';
+export interface XCheckboxOptionProps<V> {
+    disabled?: boolean;
+    label?: number | string;
+    value: V;
+}
+export interface XCheckboxProps<D, V> extends Partial<Omit<CheckboxProps, 'options' | 'modelValue'>> {
+    data: D[];
+    factory: (option: D) => XCheckboxOptionProps<V>;
+    identify?: (value: V) => number | string;
+}
+declare const _default: <D, V, MV extends V>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: MV[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: MV[];
+    } & XCheckboxProps<D, V>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: MV[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XColorPicker.vue.d.ts

@@ -0,0 +1,21 @@
+export interface XColorPickerProps {
+    clearable?: boolean;
+    disabled?: boolean;
+}
+declare const _default: <D, V extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: V;
+    } & XColorPickerProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: V) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XDialog.vue.d.ts

@@ -0,0 +1,36 @@
+import { Component } from 'vue';
+export interface XDialogProps {
+    title?: string;
+    bodyClass?: string;
+}
+type __VLS_Props = XDialogProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => Component;
+        header?: () => Component;
+        footer?: () => Component;
+    }> & {
+        default?: () => Component;
+        header?: () => Component;
+        footer?: () => Component;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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/dist/basic/XDivider.vue.d.ts

@@ -0,0 +1,20 @@
+import { DividerProps } from 'element-plus';
+export interface XDividerProps extends Partial<DividerProps> {
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XDividerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XDividerProps> & 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/dist/basic/XForm.vue.d.ts

@@ -0,0 +1,54 @@
+import { VNodeChild } from 'vue';
+export interface XFormItemConfig<D> extends Omit<XFormItemProps, 'content' | 'label'> {
+    content?: (scope: {
+        data: D;
+    }) => VNodeChild;
+    label: string;
+}
+export interface XFormProps<D> {
+    content?: (scope: {
+        data: D;
+    }) => VNodeChild;
+    data?: D;
+    disabled?: boolean;
+    inline?: boolean;
+    labelWidth?: number | string;
+    labelPosition?: 'left' | 'right' | 'top';
+    statusIcon?: boolean;
+}
+export interface XFormItemProps {
+    content?: () => VNodeChild;
+    label?: string;
+    labelPosition?: '' | 'left' | 'right' | 'top';
+    labelWidth?: number | string;
+    required?: boolean;
+    tooltip?: {
+        type?: 'success' | 'warning';
+        content?: string;
+    };
+}
+export interface XFormItemValidation {
+    label: string;
+    required: boolean;
+    clearValidate: () => void;
+    validate: () => boolean;
+    validator?: () => string | void;
+}
+export declare const XFormItem: import('vue').DefineSetupFnComponent<XFormItemProps, {}, {}, XFormItemProps & {}, import('vue').PublicProps>;
+declare const _default: <D extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & XFormProps<D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        data: D | (() => void);
+        validate: () => boolean;
+        resetFields: () => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XImage.vue.d.ts

@@ -0,0 +1,5 @@
+import { ImageProps } from 'element-plus';
+export interface XImageProps extends Partial<ImageProps> {
+}
+declare const _default: import('vue').DefineComponent<XImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XImageProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/basic/XInput.vue.d.ts

@@ -0,0 +1,29 @@
+import { InputProps } from 'element-plus';
+export interface XInputProps {
+    clearable?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: InputProps['size'];
+    type?: InputProps['type'];
+    showPassword?: boolean;
+    autosize?: InputProps['autosize'];
+}
+declare const _default: <V extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        readonly onBlur?: (() => any) | undefined;
+        readonly onChange?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange"> & ({
+        modelValue?: V;
+    } & XInputProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "blur") => void) & ((evt: "change", value: V) => void)) & ((evt: "update:modelValue", value: V) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XInputNumber.vue.d.ts

@@ -0,0 +1,31 @@
+import { InputNumberProps } from 'element-plus';
+export interface XInputNumberProps {
+    placeholder?: string;
+    disabled?: boolean;
+    align?: InputNumberProps['align'];
+    size?: InputNumberProps['size'];
+    step?: number;
+    max?: number;
+    min?: number;
+    controls?: boolean;
+    precision?: number;
+    stepStrictly?: boolean;
+}
+declare const _default: <V extends number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        readonly onBlur?: (() => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur"> & ({
+        modelValue?: V;
+    } & XInputNumberProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "blur") => void) & ((evt: "update:modelValue", value: V) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XPagination.vue.d.ts

@@ -0,0 +1,21 @@
+import { PaginationProps } from 'element-plus';
+export interface XPaginationProps extends Partial<Omit<PaginationProps, 'pageSizes'>> {
+    sizes?: number[];
+}
+type __VLS_Props = XPaginationProps;
+type __VLS_PublicProps = {
+    'size'?: number;
+    'current'?: number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sizeChange: (size: number) => any;
+    currentChange: (current: number) => any;
+    "update:size": (value: number) => any;
+    "update:current": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSizeChange?: ((size: number) => any) | undefined;
+    onCurrentChange?: ((current: number) => any) | undefined;
+    "onUpdate:size"?: ((value: number) => any) | undefined;
+    "onUpdate:current"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/basic/XRate.vue.d.ts

@@ -0,0 +1,20 @@
+import { RateProps } from 'element-plus';
+export interface XRateProps extends Partial<Omit<RateProps, 'modelValue'>> {
+}
+declare const _default: <V extends number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: V;
+    } & XRateProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: V) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/basic/XReconfirm.vue.d.ts

@@ -0,0 +1,26 @@
+export interface XReconfirmProps {
+    title?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XReconfirmProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<XReconfirmProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+    };
+};