@fox-js/foxui 4.0.1-3 → 4.0.1-5

package/dist/types/components/calendaritem/common.d.ts

@@ -179,7 +179,7 @@ export declare function component(componentName: string, scope: string, Calendar
         hintProps: {
             type: ObjectConstructor;
             required: boolean;
-            deefault: {};
+            default: {};
         };
         hasBorder: {
             type: BooleanConstructor;

package/dist/types/components/content/common.d.ts

@@ -0,0 +1,16 @@
+import { PropType, CSSProperties } from 'vue';
+import { Padding } from '../../utils/domain';
+export declare function component(componentName: string, scope: string): {
+    props: {
+        padding: {
+            type: PropType<Padding>;
+            required: boolean;
+        };
+    };
+    setup(props: Record<string, any>): {
+        classes: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        styles: import("vue").ComputedRef<CSSProperties>;
+    };
+};

package/dist/types/components/datepicker/common.d.ts

@@ -48,6 +48,18 @@ export declare let datepickerProps: {
         default: () => Date;
         validator: (val: unknown) => val is Date;
     };
+    visibleItemCount: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    threeDimensional: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    swipeDuration: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
     isWrapTeleport: {
         type: BooleanConstructor;
         default: boolean;

package/dist/types/components/fixednav/common.d.ts

@@ -0,0 +1,51 @@
+import { PropType } from 'vue';
+export declare const component: (componentName: string, scope: string) => {
+    props: {
+        visible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        overlay: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        navList: {
+            default: () => never[];
+            type: PropType<any[]>;
+        };
+        activeColor: {
+            default: string;
+            type: StringConstructor;
+        };
+        activeText: {
+            default: string;
+            type: StringConstructor;
+        };
+        unActiveText: {
+            default: string;
+            type: StringConstructor;
+        };
+        position: {
+            default: () => {
+                top: string;
+                bottom: string;
+            };
+            type: ObjectConstructor;
+        };
+        type: {
+            default: string;
+            type: StringConstructor;
+        };
+    };
+    emits: string[];
+    setup(props: any, { emit }: any): {
+        classes: import("vue").ComputedRef<{
+            [x: string]: any;
+            [x: number]: boolean;
+            active: any;
+        }>;
+        updateValue: (value?: boolean) => void;
+        selected: (item: any, event: Event) => void;
+        current: import("vue").Ref<number>;
+    };
+};

package/dist/types/components/footer/common.d.ts

@@ -0,0 +1,22 @@
+import { PropType, SetupContext, CSSProperties } from 'vue';
+import { Padding } from '../../utils/domain';
+import type { AlignType } from './type';
+export declare function component(componentName: string, scope: string): {
+    props: {
+        padding: {
+            type: PropType<Padding>;
+            required: boolean;
+        };
+        align: {
+            type: PropType<AlignType>;
+            required: boolean;
+            default: string;
+        };
+    };
+    setup(props: Record<string, any>, context: SetupContext): {
+        classes: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        styles: import("vue").ComputedRef<CSSProperties>;
+    };
+};

package/dist/types/components/footer/type.d.ts

@@ -0,0 +1 @@
+export declare type AlignType = 'left' | 'center' | 'right';

package/dist/types/components/header/common.d.ts

@@ -0,0 +1,87 @@
+import { PropType, SetupContext, CSSProperties } from 'vue';
+import { Padding } from '../../utils/domain';
+import { IconParams, Tab } from './types';
+export declare const component: (componentName: string, scope: string) => {
+    props: {
+        padding: {
+            type: PropType<Padding>;
+            required: boolean;
+        };
+        leftShow: {
+            type: (BooleanConstructor | StringConstructor)[];
+            required: boolean;
+            default: boolean;
+        };
+        leftIcon: {
+            type: PropType<string | IconParams>;
+            required: boolean;
+            default: string;
+        };
+        leftText: {
+            type: StringConstructor;
+            required: boolean;
+            default: string;
+        };
+        titleShow: {
+            type: BooleanConstructor;
+            required: boolean;
+            default: boolean;
+        };
+        defaultIndex: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: number;
+        };
+        tabs: {
+            type: PropType<Tab[]>;
+            default: () => never[];
+        };
+        title: {
+            type: StringConstructor;
+            required: boolean;
+            default: string;
+        };
+        titleIcon: {
+            type: PropType<string | IconParams>;
+            required: boolean;
+            default: string;
+        };
+        rightShow: {
+            type: (BooleanConstructor | StringConstructor)[];
+            required: boolean;
+            default: boolean;
+        };
+        rightIcon: {
+            type: PropType<string | IconParams>;
+            required: boolean;
+            default: string;
+        };
+        rightText: {
+            type: StringConstructor;
+            required: boolean;
+            default: string;
+        };
+    };
+    emits: string[];
+    setup(props: Record<string, any>, context: SetupContext): {
+        classes: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        styles: import("vue").ComputedRef<CSSProperties>;
+        activeIndex: import("vue").Ref<string | number>;
+        leftStyles: import("vue").ComputedRef<CSSProperties>;
+        rightStyles: import("vue").ComputedRef<CSSProperties>;
+        tabStyles: import("vue").ComputedRef<CSSProperties>;
+        mLeftShow: import("vue").ComputedRef<any>;
+        mTitleShow: import("vue").ComputedRef<any>;
+        mTabsShow: import("vue").ComputedRef<any>;
+        mRightShow: import("vue").ComputedRef<any>;
+        mLeftIcon: import("vue").ComputedRef<Record<string, any>>;
+        mTitleIcon: import("vue").ComputedRef<Record<string, any>>;
+        mRightIcon: import("vue").ComputedRef<Record<string, any>>;
+        handleLeft: () => void;
+        handleCenter: () => void;
+        handleRight: () => void;
+        handleRightText: () => void;
+        handleTabChange: (id: number | string, name: string) => void;
+    };
+};

package/dist/types/components/item/common.d.ts

@@ -111,7 +111,7 @@ export declare const itemProps: {
     hintProps: {
         type: ObjectConstructor;
         required: boolean;
-        deefault: {};
+        default: {};
     };
     hasBorder: {
         type: BooleanConstructor;

package/dist/types/components/linkitem/common.d.ts

@@ -110,7 +110,7 @@ export declare function component(componentName: string, scope: string, Icon: an
         hintProps: {
             type: ObjectConstructor;
             required: boolean;
-            deefault: {};
+            default: {};
         };
         hasBorder: {
             type: BooleanConstructor;

package/dist/types/components/page/common.d.ts

@@ -0,0 +1,78 @@
+import { CSSProperties, PropType, SetupContext } from 'vue';
+import { SafeAreaInset } from '../../utils/domain';
+import { Rect } from '../../utils/types';
+export declare const component: (componentName: string, scope: string) => {
+    props: {
+        name: {
+            type: PropType<string>;
+            required: boolean;
+            default: string;
+        };
+        width: {
+            type: (StringConstructor | NumberConstructor)[];
+            required: boolean;
+        };
+        height: {
+            type: (StringConstructor | NumberConstructor)[];
+            required: boolean;
+        };
+        safeAreaInset: {
+            type: PropType<SafeAreaInset>;
+            required: boolean;
+        };
+        contentPadding: {
+            type: PropType<Rect>;
+            required: boolean;
+        };
+        headerPadding: {
+            type: PropType<Rect>;
+            required: boolean;
+        };
+        footerPadding: {
+            type: PropType<Rect>;
+            required: boolean;
+        };
+        headerHeight: {
+            type: (StringConstructor | NumberConstructor)[];
+            required: boolean;
+        };
+        footerHeight: {
+            type: (StringConstructor | NumberConstructor)[];
+            required: boolean;
+        };
+        column: {
+            type: PropType<string | number>;
+            required: boolean;
+        };
+        gutter: {
+            type: PropType<string | number>;
+            required: boolean;
+        };
+        disabled: {
+            type: (BooleanConstructor | StringConstructor)[];
+            required: boolean;
+        };
+        readonly: {
+            type: (BooleanConstructor | StringConstructor)[];
+            required: boolean;
+        };
+        labelPosition: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        labelWidth: {
+            type: (StringConstructor | NumberConstructor)[];
+            required: boolean;
+        };
+        hasBorder: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    setup(props: Record<string, unknown>, context: SetupContext): {
+        classes: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        styles: import("vue").ComputedRef<CSSProperties>;
+    };
+};

package/dist/types/components/picker/common.d.ts

@@ -1,5 +1,33 @@
 import { PropType } from 'vue';
-import { CloumnOptions, SourceFunction, ItemType, ValueType } from './model';
+import { ColumnOptions, Item, SourceFunction, ValueType } from './types';
+export declare const commonColumnProps: {
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    visibleItemCount: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    textName: {
+        type: PropType<string>;
+        required: boolean;
+        default: string;
+    };
+    valueName: {
+        type: PropType<string>;
+        required: boolean;
+        default: string;
+    };
+    threeDimensional: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    swipeDuration: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+};
 export declare const pickerProps: {
     modelValue: {
         type: (BooleanConstructor | StringConstructor | NumberConstructor | ObjectConstructor | ArrayConstructor)[];
@@ -10,10 +38,10 @@ export declare const pickerProps: {
         default: never[];
     };
     columnOptions: {
-        type: PropType<CloumnOptions>;
+        type: PropType<ColumnOptions>;
     };
     source: {
-        type: PropType<string | ItemType[] | SourceFunction>;
+        type: PropType<string | Item[] | SourceFunction>;
         default: never[];
     };
     params: {
@@ -58,9 +86,13 @@ export declare const pickerProps: {
         required: boolean;
         default: string;
     };
-    itemOptions: {
-        type: PropType<import("./model").ItemOptions>;
-        required: boolean;
+    threeDimensional: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    swipeDuration: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
     };
     position: {
         type: StringConstructor;

package/dist/types/components/picker/model.d.ts

@@ -1,55 +1,25 @@
 import { ComponentPublicInstance } from 'vue';
+import { Item, ColumnOptionsObject, ValueType, SourceFunction, DataType } from './types';
 export declare function getGlobalItemHeight(): number;
 export declare function setGlobalItemHeight(h: number): void;
-export declare type DataType = 'singleColumn' | 'multipleColumn' | 'cascade';
-export interface ItemType {
-    text: string;
-    value: any;
-    children?: ItemType[] | null;
-    [propName: string]: any;
-}
-export declare function getItemIndex(props: Record<string, any>, items: ItemType[], value: number | string | boolean | ItemType, valueType?: ValueType): number;
-export declare function getItemText(props: Record<string, any>, item: ItemType): string;
-export declare function getItemValue(props: Record<string, any>, item: ItemType): string | boolean | number;
-export interface ItemOptionsObject {
-    disabled: boolean;
-    [propName: string]: any;
-}
-export interface ItemOptionsFunction {
-    (item?: any, index?: number): ItemOptionsObject;
-}
-export declare type ItemOptions = ItemOptionsObject | ItemOptionsFunction;
-export declare function getItemOptions(props: {
-    [propName: string]: any;
-}, item: ItemType, column: number, index: number): ItemOptionsObject | null;
-export interface ColumnOptionsObject {
-    readonly: boolean;
-    defautIndex?: number;
-    [propName: string]: any;
-}
-export interface ColumnOptionsFunction {
-    (index?: number): ColumnOptionsObject;
-}
-export declare type CloumnOptions = ColumnOptionsObject | ColumnOptionsFunction;
-export declare function getCoumnOptions(props: {
+export declare function getItemIndex(props: Record<string, any>, items: Item[], value: number | string | boolean | Item, valueType?: ValueType): number;
+export declare function getItemText(props: Record<string, any>, item: Item): string;
+export declare function getItemValue(props: Record<string, any>, item: Item): string | boolean | number;
+export declare function getColumnOptions(props: {
     [propName: string]: any;
 }, index: number): ColumnOptionsObject;
-export interface SourceFunction {
-    (params?: any): Promise<ItemType[][] | ItemType[]>;
-}
-export declare type ValueType = 'value' | 'text' | 'item';
 export declare class Model {
     private proxy;
     constructor(proxy: ComponentPublicInstance);
-    load(componentType: string, src: SourceFunction | ItemType[][] | ItemType[] | string, params?: any): Promise<ItemType[][] | ItemType[] | string[] | string[][]>;
+    load(componentType: string, src: SourceFunction | Item[][] | Item[] | string, params?: any): Promise<Item[][] | Item[] | string[] | string[][]>;
 }
 export declare function useModel(): Model;
-export declare function isEqualsItem(props: Record<string, any>, x: ItemType, y: ItemType): boolean;
-export declare function valuesToIndexs(props: Record<string, any>, value: any, columns: ItemType[][], dataType: DataType): number[];
+export declare function isEqualsItem(props: Record<string, any>, x: Item, y: Item): boolean;
+export declare function valuesToIndexs(props: Record<string, any>, value: any, columns: Item[][], dataType: DataType): number[];
 interface Result {
     texts: string[];
-    values: (ItemType | string | number | boolean)[];
+    values: (Item | string | number | boolean)[];
 }
-export declare function indexsToResult(props: Record<string, any>, indexs: number[], columns: ItemType[][], dataType: DataType): Result | null;
-export declare function stringToItem(text: string): ItemType;
+export declare function indexsToResult(props: Record<string, any>, indexs: number[], columns: Item[][], dataType: DataType): Result | null;
+export declare function stringToItem(text: string): Item;
 export {};

package/dist/types/components/picker/types.d.ts

@@ -0,0 +1,20 @@
+export interface Item {
+    text: string;
+    value: any;
+    children?: Item[] | null;
+    [propName: string]: any;
+}
+export interface ColumnOptionsObject {
+    readonly: boolean;
+    defaultIndex?: number;
+    [propName: string]: any;
+}
+export interface ColumnOptionsFunction {
+    (index?: number): ColumnOptionsObject;
+}
+export declare type ColumnOptions = ColumnOptionsObject | ColumnOptionsFunction;
+export interface SourceFunction {
+    (params?: any): Promise<Item[][] | Item[]>;
+}
+export declare type ValueType = 'value' | 'text' | 'item';
+export declare type DataType = 'singleColumn' | 'multipleColumn' | 'cascade';

package/dist/types/components/searchbar/type.d.ts

@@ -3,3 +3,4 @@ export interface Events {
     params: (string | number | Event)[];
 }
 export declare type ConfirmTextType = 'send' | 'search' | 'next' | 'go' | 'done';
+export declare type TextAlign = 'start' | 'end' | 'left' | 'right' | 'center' | 'justify' | 'match-parent';

package/dist/types/components/table/common.d.ts

@@ -44,9 +44,12 @@ export declare const component: (componentName: string, scope: string) => {
             'fox-table__main__head__tr--border': any;
         };
         getColumnItem: (value: string) => TableColumnProps;
+        getColumnItemStyle: (value: string) => any;
         handleSorterClick: (item: TableColumnProps) => void;
         sortDataItem: () => any;
         t: (key: string | string[], ...args: unknown[]) => string;
+        stylehead: (item: TableColumnProps) => string;
+        stylecolumn: (item: TableColumnProps) => string;
         curData: import("vue").Ref<any>;
     };
 };

package/dist/types/components/table/types.d.ts

@@ -3,6 +3,8 @@ export interface TableColumnProps {
     key?: string;
     title?: string;
     align?: string;
+    stylehead?: string;
+    stylecolumn?: string;
     sorter?: Function;
     render?: (rowData?: object, rowIndex?: number) => VNodeChild | string | VNode;
 }

package/dist/types/components/uploader/uploader.d.ts

@@ -3,6 +3,7 @@ export declare class UploadOptions {
     name: string;
     fileType?: string | undefined;
     formData?: FormData;
+    sourceFile: any;
     method: string;
     xhrState: number;
     timeout: number;
@@ -13,6 +14,7 @@ export declare class UploadOptions {
     onProgress?: Function;
     onSuccess?: Function;
     onFailure?: Function;
+    beforeXhrUpload?: Function;
 }
 export declare class Uploader {
     options: UploadOptions;

package/dist/types/interface.d.ts

@@ -4,17 +4,20 @@ import { ScopeGetter } from './api';
 import { GroupLayout } from './utils/domain/group';
 import { SafeAreaInset, PageLayout, Domain } from './utils/domain';
 export interface FoxUIOptions {
+    headerBarHeight?: number;
+    footerBarHeight?: number;
     safeAreaInset?: SafeAreaInset;
     pageLayout?: PageLayout;
     headerPadding?: Rect;
     contentPadding?: Rect;
-    groupLaout?: GroupLayout;
+    groupLayout?: GroupLayout;
     labelWidth?: number | string;
     [propName: string]: any;
 }
 export interface FoxUI {
     version: string;
     install(app: App, options: FoxUIOptions): void;
+    initPageLayout(options: FoxUIOptions, rootDomain?: Domain): void;
     setScopeGetter(getter: ScopeGetter): void;
     setAPI(name: string, func: any, scope?: string): void;
     getAPI(proxy: ComponentPublicInstance, name: string, scope?: string): any | null;

package/dist/types/main.d.ts

@@ -8,6 +8,7 @@ export declare class FoxUIApp implements FoxUI {
     get version(): string;
     constructor(packages: any[], version: string);
     install(app: App, options: FoxUIOptions): void;
+    initPageLayout(options: FoxUIOptions, rootDomain?: Domain): void;
     setScopeGetter(getter: ScopeGetter): void;
     setAPI(name: string, api: any, scope?: string): void;
     getAPI(proxy: ComponentPublicInstance, name: string, scope?: string): any | null;

package/dist/types/utils/domain/page.d.ts

@@ -1,25 +1,49 @@
 import { Domain } from './domain';
+import { UnwrapNestedRefs } from 'vue';
 export interface SafeAreaInset {
     left: number | string;
     top: number | string;
     right: number | string;
     bottom: number | string;
 }
+export interface Padding {
+    left: number | null;
+    top: number | null;
+    right: number | null;
+    bottom: number | null;
+}
 export interface PageLayout {
     width: number | string;
     height: number | string;
     headerHeight: number | string;
     footerHeight: number | string;
+    headerPadding?: Padding;
+    footerPadding?: Padding;
+    contentPadding?: Padding;
+}
+export interface PageState {
+    width: number;
+    height: number;
+    headerHeight: number;
+    headerPadding: Padding;
+    footerHeight: number;
+    footerPadding: Padding;
+    contentHeight: number | string | null;
+    contentPadding: Padding;
+    safeAreaTop: number;
+    safeAreaBottom: number;
+    safeAreaLeft: number;
+    safeAreaRight: number;
+    headerMounted?: boolean;
+    footerMounted?: boolean;
 }
-export declare function createPageState(domain: Domain, source?: Record<string, number>): any;
-export declare function getPageHeaderHeight(domain: Domain): number;
-export declare function setPageHeaderHeight(domain: Domain, height: number): void;
-export declare function getPageFooterHeight(domain: Domain): number;
-export declare function setPageFooterHeight(domain: Domain, height: number): void;
-export declare function getPageContentHeight(domain: Domain): number;
-export declare function setPageContentHeight(domain: Domain, height: number): void;
-export declare function getPageContentWidth(domain: Domain): number;
-export declare function setPageContentWidth(domain: Domain, width: number): void;
+export declare function toPadding(rect: any): Padding;
+export declare function updatePageState(state: PageState, pageLayout: any, overrideProps?: Record<string, unknown>, root?: boolean, rootWidth?: number, rootHeight?: number): void;
+export declare function definePageState(domain: Domain, overrideProps?: Record<string, unknown>): UnwrapNestedRefs<PageState> | null;
+export declare function usePageState(domain: Domain): PageState | null;
+export declare function getPageHeaderAreaHeight(domain: Domain, state?: PageState): number;
+export declare function getPageFooterAreaHeight(domain: Domain, state?: PageState): number;
+export declare function getPageContentAreaHeight(domain: Domain, state?: PageState): number;
+export declare function getPageContentAreaWidth(domain: Domain, state?: PageState): number;
+export declare function isInnerPage(domain: Domain, proxy: any): boolean;
 export declare function isSubPage(domain: Domain): boolean;
-export declare function getParentPageContentHeight(domain: Domain): number;
-export declare function getParentPageContentWidth(domain: Domain): number;

package/dist/types/utils/domain/validator.d.ts

@@ -4,12 +4,12 @@ export interface ValidateHandler {
     error?(errorMsg: string, proxy: ComponentPublicInstance, instance: ComponentInternalInstance): void;
     reset?(proxy: ComponentPublicInstance, instance: ComponentInternalInstance): void;
     success?(proxy: ComponentPublicInstance, instance: ComponentInternalInstance): void;
-    decorate?(rule: Rule, proxy: ComponentPublicInstance, instance: ComponentInternalInstance): void;
+    decorate?(newRule: Rule, oldRle: Rule, proxy: ComponentPublicInstance, instance: ComponentInternalInstance): void;
     getValue?(proxy: ComponentPublicInstance, instance: ComponentInternalInstance): any;
 }
 export declare function setGlobalValidateHandler(validateHandler: ValidateHandler): void;
 export declare function setGlobalValidator(type: string, validator: ExecuteValidator): void;
-export declare function deleteGloabalValidator(type: string): void;
+export declare function deleteGlobalValidator(type: string): void;
 export declare function setGlobalValidateCheckEvents(events: string[]): void;
 export declare function getGlobalValidateCheckEvents(): string[];
 export declare function setGlobalValidateResetEvents(events: string[]): void;
@@ -40,7 +40,7 @@ export declare class ValidateSchema {
     destroy(): void;
     addChild(child: ValidateSchema): void;
     removeChild(child: ValidateSchema): void;
-    private execHandlder;
+    private execHandler;
     private decorate;
     private success;
     private error;

package/dist/types/utils/use-expose/index.d.ts

@@ -1 +1,2 @@
-export declare function useExpose(apis: Record<string, any>): void;
+import { ComponentInternalInstance } from 'vue';
+export declare function useExpose(apis: Record<string, any>, instance?: ComponentInternalInstance | null): void;

package/dist/types/utils/use-touch/index.d.ts

@@ -5,6 +5,8 @@ export declare function useTouch(): {
     reset: () => void;
     startX: import("vue").Ref<number>;
     startY: import("vue").Ref<number>;
+    startTime: import("vue").Ref<number>;
+    duration: import("vue").Ref<number>;
     moveX: import("vue").Ref<number>;
     moveY: import("vue").Ref<number>;
     deltaX: import("vue").Ref<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fox-js/foxui",
-  "version": "4.0.1-3",
+  "version": "4.0.1-5",
   "description": "FoxUI轻量级移动端组件库（支持小程序开发）",
   "author": "jiangcheng",
   "main": "dist/foxui.umd.js",