@yelingfeng/pandora2 0.1.3

package/dist/packages/components/PdForm/src/hooks/useFormEvents.d.ts

@@ -0,0 +1,28 @@
+import { FormItemProp } from 'element-plus';
+import type { ComputedRef, Ref } from 'vue';
+import type { Callback, EmitType, Fn, IFormActionType, IFormProps, IFormSchema } from '../types';
+interface UseFormActionContext {
+    emit: EmitType;
+    getProps: ComputedRef<IFormProps>;
+    getSchema: ComputedRef<IFormSchema[]>;
+    formModel: Recordable;
+    defaultValueRef: Ref<Recordable>;
+    formElRef: Ref<IFormActionType>;
+    schemaRef: Ref<IFormSchema[]>;
+    handleFormValues: Fn;
+}
+export declare function useFormEvents({ emit, getProps, formModel, getSchema, defaultValueRef, formElRef, schemaRef, handleFormValues }: UseFormActionContext): {
+    handleSubmit: (e?: Event) => Promise<void>;
+    clearValidate: (name?: string | string[]) => Promise<void>;
+    validate: (cb?: Callback) => Promise<void>;
+    validateFields: (props?: FormItemProp[] | undefined, callback?: Callback | undefined) => Promise<void>;
+    getFieldsValue: () => Recordable;
+    updateSchema: (data: Partial<IFormSchema> | Partial<IFormSchema>[]) => Promise<void>;
+    resetSchema: (data: Partial<IFormSchema> | Partial<IFormSchema>[]) => Promise<void>;
+    appendSchemaByField: (schema: IFormSchema, prefixField?: string, first?: boolean) => Promise<void>;
+    removeSchemaByFiled: (fields: string | string[]) => Promise<void>;
+    resetFields: () => Promise<void>;
+    setFieldsValue: (values: Recordable) => Promise<void>;
+    scrollToField: (name: string, options?: ScrollOptions | undefined) => Promise<void>;
+};
+export {};

package/dist/packages/components/PdForm/src/hooks/useFormValues.d.ts

@@ -0,0 +1,13 @@
+import { IFormProps, IFormSchema } from '../types';
+import { Ref, ComputedRef } from 'vue';
+interface UseFormValuesContext {
+    defaultValueRef: Ref<any>;
+    getSchema: ComputedRef<IFormSchema[]>;
+    getProps: ComputedRef<IFormProps>;
+    formModel: Recordable;
+}
+export declare function useFormValues({ defaultValueRef, getSchema, getProps, formModel }: UseFormValuesContext): {
+    handleFormValues: (values: Recordable) => Recordable<any>;
+    initDefault: () => void;
+};
+export {};

package/dist/packages/components/PdForm/src/props/index.d.ts

@@ -0,0 +1,112 @@
+import type { FieldMapToTime, IFormSchema, Fn } from '../types';
+import type { CSSProperties, PropType } from 'vue';
+import type { ButtonProps, ColProps, RowProps } from 'element-plus';
+export declare const FormBasicProps: {
+    model: {
+        type: PropType<Recordable<any>>;
+        default: {};
+    };
+    labelWidth: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    fieldMapToTime: {
+        type: PropType<FieldMapToTime>;
+        default: () => never[];
+    };
+    schemas: {
+        type: PropType<IFormSchema[]>;
+        default: () => never[];
+    };
+    mergeDynamicData: {
+        type: PropType<Recordable<any>>;
+        default: null;
+    };
+    baseRowStyle: {
+        type: PropType<CSSProperties>;
+    };
+    baseColProps: {
+        type: PropType<Partial<ColProps>>;
+    };
+    autoSetPlaceHolder: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    autoSubmitOnEnter: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    submitOnReset: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    submitOnChange: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    emptySpan: {
+        type: PropType<number>;
+        default: number;
+    };
+    showAdvancedButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    transformDateFunc: {
+        type: PropType<Fn>;
+        default: (date: any) => any;
+    };
+    rulesMessageJoinLabel: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    autoAdvancedLine: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    alwaysShowLines: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    showActionButtonGroup: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    actionColOptions: PropType<Partial<ColProps>>;
+    showResetButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    autoFocusFirstItem: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    resetButtonOptions: PropType<Partial<ButtonProps>>;
+    showSubmitButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    submitButtonOptions: PropType<Partial<ButtonProps>>;
+    resetFunc: PropType<() => Promise<void>>;
+    submitFunc: PropType<() => Promise<void>>;
+    hideRequiredMark: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    labelAlign: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    rowProps: PropType<RowProps>;
+    rules: PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+};

package/dist/packages/components/PdForm/src/types/formItem.d.ts

@@ -0,0 +1,81 @@
+import type { ColProps } from 'element-plus';
+import type { HTMLAttributes, VNodeChild } from 'vue';
+export type IFormItem = {
+    /**
+     * Used with label, whether to display : after label text.
+     * @default true
+     * @type boolean
+     */
+    colon?: boolean;
+    /**
+     * The extra prompt message. It is similar to help. Usage example: to display error message and prompt message at the same time.
+     * @type any (string | slot)
+     */
+    extra?: string | VNodeChild | JSX.Element;
+    /**
+     * Used with validateStatus, this option specifies the validation status icon. Recommended to be used only with Input.
+     * @default false
+     * @type boolean
+     */
+    hasFeedback?: boolean;
+    /**
+     * The prompt message. If not provided, the prompt message will be generated by the validation rule.
+     * @type any (string | slot)
+     */
+    help?: string | VNodeChild | JSX.Element;
+    /**
+     * Label test
+     * @type any (string | slot)
+     */
+    label?: string | VNodeChild | JSX.Element;
+    /**
+     * The layout of label. You can set span offset to something like {span: 3, offset: 12} or sm: {span: 3, offset: 12} same as with <Col>
+     * @type Col
+     */
+    labelCol?: ColProps & HTMLAttributes;
+    /**
+     * Whether provided or not, it will be generated by the validation rule.
+     * @default false
+     * @type boolean
+     */
+    required?: boolean;
+    /**
+     * The validation status. If not provided, it will be generated by validation rule. options: 'success' 'warning' 'error' 'validating'
+     * @type string
+     */
+    validateStatus?: '' | 'success' | 'warning' | 'error' | 'validating';
+    /**
+     * The layout for input controls, same as labelCol
+     * @type Col
+     */
+    wrapperCol?: ColProps;
+    /**
+     * Set sub label htmlFor.
+     */
+    htmlFor?: string;
+    /**
+     * text align of label
+     */
+    labelAlign?: 'left' | 'right';
+    /**
+     * a key of model. In the setting of validate and resetFields method, the attribute is required
+     */
+    name?: string;
+    /**
+     * validation rules of form
+     */
+    rules?: object | object[];
+    /**
+     * Whether to automatically associate form fields. In most cases, you can setting automatic association.
+     * If the conditions for automatic association are not met, you can manually associate them. See the notes below.
+     */
+    autoLink?: boolean;
+    /**
+     * Whether stop validate on first rule of error for this field.
+     */
+    validateFirst?: boolean;
+    /**
+     * When to validate the value of children node
+     */
+    validateTrigger?: string | string[] | false;
+};

package/dist/packages/components/PdForm/src/types/hooks.d.ts

@@ -0,0 +1,6 @@
+export interface AdvanceState {
+    isAdvanced: boolean;
+    hideAdvanceBtn: boolean;
+    isLoad: boolean;
+    actionSpan: number;
+}

package/dist/packages/components/PdForm/src/types/index.d.ts

@@ -0,0 +1,133 @@
+import type { ValidateFieldsError } from 'async-validator';
+import type { ButtonProps, ColProps, FormItemProp, FormItemRule, FormRules, RowProps } from 'element-plus';
+import type { ComputedRef, CSSProperties, Ref, VNode } from 'vue';
+export type Fn = (...args: any[]) => any;
+export type EmitType = (event: string, ...args: any[]) => void;
+export type FieldMapToTime = [string, [string, string], string?][];
+export type IFormProps = {
+    name?: string;
+    model?: Record<string, any>;
+    labelPosition?: 'left' | 'right' | 'top';
+    labelWidth?: string | number;
+    labelSuffix?: string;
+    size?: 'large' | 'default' | 'small';
+    inline?: boolean;
+    disabled?: boolean;
+    rules?: FormRules;
+    compact?: boolean;
+    emptySpan?: number | Partial<ColProps>;
+    rowProps?: RowProps;
+    submitOnReset?: boolean;
+    submitOnChange?: boolean;
+    labelCol?: Partial<ColProps>;
+    wrapperCol?: Partial<ColProps>;
+    baseRowStyle?: CSSProperties;
+    baseColProps?: Partial<ColProps>;
+    schemas?: IFormSchema[];
+    mergeDynamicData?: Recordable;
+    autoSetPlaceHolder?: boolean;
+    autoSubmitOnEnter?: boolean;
+    rulesMessageJoinLabel?: boolean;
+    showAdvancedButton?: boolean;
+    autoFocusFirstItem?: boolean;
+    autoAdvancedLine?: number;
+    alwaysShowLines?: number;
+    showActionButtonGroup?: boolean;
+    fieldMapToTime?: FieldMapToTime;
+    resetButtonOptions?: Partial<ButtonProps>;
+    submitButtonOptions?: Partial<ButtonProps>;
+    actionColOptions?: Partial<ColProps>;
+    showResetButton?: boolean;
+    showSubmitButton?: boolean;
+    hideRequiredAsterisk?: boolean;
+    showMessage?: boolean;
+    inlineMessage?: boolean;
+    statusIcon?: boolean;
+    validateOnRuleChange?: boolean;
+    resetFunc?: () => Promise<void>;
+    submitFunc?: () => Promise<void>;
+    transformDateFunc?: (date: any) => string;
+    layout?: 'horizontal' | 'vertical' | 'inline';
+};
+export type RenderCallbackParams = {
+    schema: IFormSchema;
+    values: Recordable;
+    model: Recordable;
+    field: string;
+};
+export type HelpComponentProps = {
+    maxWidth: string;
+    showIndex: boolean;
+    text: any;
+    color: string;
+    fontSize: string;
+    icon: string;
+    absolute: boolean;
+    position: any;
+};
+/**
+ * Form Schema
+ */
+export type IFormSchema = {
+    field: string;
+    label: string;
+    changeEvent?: string;
+    component: ComponentType;
+    componentProps?: ((opt: {
+        schema: IFormSchema;
+        formModel: Recordable;
+    }) => Recordable) | any;
+    rules?: FormItemRule | FormItemRule[];
+    required?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    suffix?: string | number | ((values: RenderCallbackParams) => string | number);
+    rulesMessageJoinLabel?: boolean;
+    itemProps?: Partial<FormItemProp>;
+    colProps?: Partial<ColProps>;
+    labelCol?: Partial<ColProps>;
+    wrapperCol?: Partial<ColProps>;
+    baseRowStyle?: CSSProperties;
+    baseColProps?: Partial<ColProps>;
+    valueField?: string;
+    subLabel?: string;
+    helpMessage?: string | string[] | ((renderCallbackParams: RenderCallbackParams) => string | string[]);
+    helpComponentProps?: Partial<HelpComponentProps>;
+    defaultValue?: any;
+    isAdvanced?: boolean;
+    span?: number;
+    ifShow?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    show?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    render?: (renderCallbackParams: RenderCallbackParams) => VNode | VNode[] | string;
+    renderColContent?: (renderCallbackParams: RenderCallbackParams) => VNode | VNode[] | string;
+    renderComponentContent?: ((renderCallbackParams: RenderCallbackParams) => any) | VNode | VNode[] | string;
+    slot?: string;
+    colSlot?: string;
+    dynamicDisabled?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    dynamicRules?: (renderCallbackParams: RenderCallbackParams) => FormItemRule[];
+    labelWidth?: string | number;
+    disabledLabelWidth?: boolean;
+};
+export type Callback = {
+    (isValid?: boolean, invalidFields?: ValidateFieldsError): void;
+};
+export type DynamicProps<T> = {
+    [P in keyof T]: Ref<T[P]> | T[P] | ComputedRef<T[P]>;
+};
+export type IFormActionType = {
+    submit: () => Promise<void>;
+    resetFields: () => Promise<void>;
+    validate: (cb: Callback | undefined) => Promise<void>;
+    validateFields: (props?: Array<FormItemProp>, callback?: Callback) => Promise<void>;
+    setFieldsValue: (values: Recordable) => Promise<void>;
+    getFieldsValue: () => Recordable;
+    clearValidate: (name?: string | string[]) => Promise<void>;
+    updateSchema: (data: Partial<IFormSchema> | Partial<IFormSchema>[]) => Promise<void>;
+    resetSchema: (data: Partial<IFormSchema> | Partial<IFormSchema>[]) => Promise<void>;
+    setProps: (formProps: Partial<IFormProps>) => Promise<void>;
+    removeSchemaByFiled: (field: string | string[]) => Promise<void>;
+    appendSchemaByField?: (schema: IFormSchema, prefixField?: string, first?: boolean | any) => Promise<void>;
+    scrollToField: (name: any, options?: ScrollOptions) => Promise<void>;
+};
+export type RegisterFn = (formInstance: IFormActionType) => void;
+export type UseFormReturnType = [RegisterFn, IFormActionType];
+export type NamePath = string | number | (string | number)[];
+export type ComponentType = 'Autocomplete' | 'Button' | 'Checkbox' | 'Cascader' | 'CheckboxGroup' | 'DatePicker' | 'Input' | 'InputNumber' | 'TimePicker' | 'TimeSelect' | 'Slider' | 'Select' | 'SelectOption' | 'Radio' | 'RadioGroup' | 'Switch' | 'Rate' | 'Divider' | 'ApiSelect';

package/dist/packages/components/PdPageLayout/index.d.ts

@@ -0,0 +1,6 @@
+import index from './index.vue';
+import tree from './tree.vue';
+import type { SFCWithInstall } from '../../../src/_utils/vue/typescript';
+export declare const PdPageLayout: SFCWithInstall<typeof index>;
+export declare const PdPageTreeLayout: SFCWithInstall<typeof tree>;
+export default PdPageLayout;

package/dist/packages/components/PdTable/index.d.ts

@@ -0,0 +1,5 @@
+export declare const PdTable: import('../../../src/_utils/vue').SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+export default PdTable;
+export type TableInstance = InstanceType<typeof PdTable>;
+export * from './src/types';
+export { useTable } from './src/hooks/useTable';

package/dist/packages/components/PdTable/src/hooks/useTable.d.ts

@@ -0,0 +1,4 @@
+import type { IPandoraTableProps, UseTableReturnType } from '../types';
+type Props = Partial<IPandoraTableProps<any>>;
+export declare function useTable(props?: Props): UseTableReturnType;
+export {};

package/dist/packages/components/PdTable/src/pagination/config.d.ts

@@ -0,0 +1,8 @@
+import type { IPageConfig } from '../types';
+import { PropType } from 'vue';
+export declare const getPagerProps: () => {
+    option: {
+        type: PropType<IPageConfig>;
+        default(): IPageConfig;
+    };
+};

package/dist/packages/components/PdTable/src/props/index.d.ts

@@ -0,0 +1,20 @@
+import { PropType } from 'vue';
+import { IPandoraTableColumn, IPandoraTableSort } from '../types';
+export declare const tableProps: {
+    data: {
+        type: PropType<any>;
+        default(): never[];
+    };
+    columns: {
+        type: PropType<IPandoraTableColumn<any>[]>;
+        default(): never[];
+    };
+    sortConfig: {
+        type: PropType<IPandoraTableSort<any>>;
+        default(): {};
+    };
+    tableConfig: {
+        type: PropType<Partial<Omit<import("../types/element-type").TableProps<any>, "data" | "column">>>;
+        default(): {};
+    };
+};