@farris/ui-vue 1.7.0-beta.4 → 1.7.0

package/types/drawer/designer.d.ts

@@ -17,6 +17,10 @@ declare const _default: {
             type: BooleanConstructor;
             default: boolean;
         };
+        showWrapperInCanvas: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
         [x: string]: any;
     }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
@@ -39,6 +43,10 @@ declare const _default: {
             type: BooleanConstructor;
             default: boolean;
         };
+        showWrapperInCanvas: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>> & Readonly<{}>, () => any, {}, {}, {}, {
         [x: string]: any;
     }>;
@@ -58,6 +66,10 @@ declare const _default: {
         type: BooleanConstructor;
         default: boolean;
     };
+    showWrapperInCanvas: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     [x: string]: any;
 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;

package/types/drawer/src/designer/drawer-toolbar.design.props.d.ts

@@ -0,0 +1,12 @@
+import { ExtractPropTypes } from 'vue';
+export declare const drawerToolbarItemDesignProps: Record<string, any>;
+export type DrawerToolbarItemDesignProps = ExtractPropTypes<typeof drawerToolbarItemDesignProps>;
+export declare const drawerToolbarItemDesignResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
+export declare const drawerToolbarDesignProps: Record<string, any> & {
+    componentId: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type DrawerToolbarDesignProps = ExtractPropTypes<typeof drawerToolbarDesignProps>;
+export declare const drawerToolbarDesignResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;

package/types/drawer/src/designer/drawer.design.component.d.ts

@@ -11,6 +11,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    showWrapperInCanvas: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<Record<string, any> & {
     componentId: {
         type: StringConstructor;
@@ -24,6 +28,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    showWrapperInCanvas: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & Readonly<{}>, {
     [x: string]: any;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/types/drawer/src/designer/drawer.design.props.d.ts

@@ -12,5 +12,9 @@ export declare const drawerPropsDesignerProps: Record<string, any> & {
         type: BooleanConstructor;
         default: boolean;
     };
+    showWrapperInCanvas: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 };
 export type DrawerDesignerProps = ExtractPropTypes<typeof drawerPropsDesignerProps>;

package/types/drawer/src/schema/schema-mapper.d.ts

@@ -1,2 +1,3 @@
 import { MapperFunction } from '../../../dynamic-resolver';
 export declare const schemaMapper: Map<string, string | MapperFunction>;
+export declare const toolbarSchemaMapper: Map<string, string | MapperFunction>;

package/types/drawer/src/schema/schema-resolver.d.ts

@@ -1,2 +1,3 @@
 import { DynamicResolver } from '../../../dynamic-resolver';
 export declare function schemaResolver(resolver: DynamicResolver, schema: Record<string, any>, context: Record<string, any>): Record<string, any>;
+export declare function toolbarSchemaResolver(resolver: DynamicResolver, schema: Record<string, any>, context: Record<string, any>): Record<string, any>;

package/types/dropdown/designer.d.ts

@@ -0,0 +1,6 @@
+export declare const propsResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
+declare const _default: {
+    register(componentMap: Record<string, any>, propsResolverMap: Record<string, any>, configResolverMap: Record<string, any>, resolverMap: Record<string, any>): void;
+    registerDesigner(componentMap: Record<string, any>, propsResolverMap: Record<string, any>, configResolverMap: Record<string, any>): void;
+};
+export default _default;

package/types/dropdown/index.d.ts

@@ -1,11 +1,32 @@
-import type { App } from 'vue';
 import Dropdown from './src/dropdown.component';
+import FDropdownItem from './src/dropdown.item.component';
 export * from './src/types/types';
 export * from './src/dropdown.props';
-export { Dropdown };
+export * from './src/composition/use-dropdown';
+export { Dropdown, FDropdownItem };
 declare const _default: {
-    install(app: App): void;
-    register(componentMap: Record<string, any>, propsResolverMap: Record<string, any>, configResolverMap: Record<string, any>, resolverMap: Record<string, any>): void;
-    registerDesigner(componentMap: Record<string, any>, propsResolverMap: Record<string, any>, configResolverMap: Record<string, any>): void;
-};
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+        [x: string]: any;
+    }> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        [x: string]: any;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        [x: string]: any;
+    }> & Readonly<{}>, () => any, {}, {}, {}, {
+        [x: string]: any;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<{
+    [x: string]: any;
+}> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    [x: string]: any;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
 export default _default;

package/types/dropdown/src/dropdown.item.component.d.ts

@@ -31,10 +31,10 @@ declare const _default: import("vue").DefineComponent<{
     [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
 }>, {
     disabled: boolean;
-    active: boolean;
     value: string;
-    divide: boolean;
+    active: boolean;
     label: string;
+    divide: boolean;
     onSelect: Function;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/dropdown/src/dropdown.props.d.ts

@@ -18,4 +18,3 @@ export type DropdownButtonType = 'primary' | 'success' | 'warning' | 'danger' |
 export type DropdownButtonPosition = 'top' | 'bottom' | 'left' | 'bottom';
 export declare const dropdownProps: Record<string, any>;
 export type DropdownProps = ExtractPropTypes<typeof dropdownProps>;
-export declare const propsResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;

package/types/dynamic-form/designer.d.ts

@@ -1,10 +1,12 @@
 import { Plugin } from 'vue';
+import FDynamicFormGroup from './src/component/dynamic-form-group/dynamic-form-group.component';
 import FResponseFormDesign from './src/designer/response-form.design.component';
+export * from './src/designer/response-form-use-designer-rules';
 export declare const formPropsResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
 export declare const formGroupPropsResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
 export declare const editorResolver: import('../dynamic-resolver').EditorResolver;
 export declare const formInputPropsResolver: (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
-export { FResponseFormDesign };
+export { FResponseFormDesign, FDynamicFormGroup };
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
         [x: string]: any;

package/types/dynamic-form/index.d.ts

@@ -1,8 +1,9 @@
 import { Plugin } from 'vue';
 import FResponseForm from './src/response-form.component';
-import FDynamicFormGroup from './src/component/dynamic-form-group/dynamic-form-group.component';
-import FDynamicFormInput from './src/component/dynamic-form-input/dynamic-form-input.component';
 import FDynamicFormLabel from './src/component/dynamic-form-label/dynamic-form-label.component';
+import FDynamicFormInput from './src/component/dynamic-form-input/dynamic-form-input.component';
+import FFormControl from './src/component/form-control/form-control.component';
+import FDynamicFormGroup from './src/component/dynamic-form-group/dynamic-form-group.component';
 export * from './src/types';
 export * from './src/composition/types';
 export * from './src/response-form.props';
@@ -10,7 +11,7 @@ export * from './src/component/dynamic-form-group/dynamic-form-group.props';
 export * from './src/component/dynamic-form-input/dynamic-form-input.props';
 export * from './src/designer/response-form-use-designer-rules';
 export * from './src/composition/use-type-resolver';
-export { FResponseForm, FDynamicFormGroup, FDynamicFormInput, FDynamicFormLabel };
+export { FResponseForm, FDynamicFormLabel, FDynamicFormInput, FFormControl, FDynamicFormGroup };
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
         [x: string]: any;

package/types/dynamic-form/src/component/dynamic-form-label/dynamic-form-label.component.d.ts

@@ -1,24 +1,24 @@
 declare const _default: import("vue").DefineComponent<{
-    required: boolean;
     text: string;
+    required: boolean;
+    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
     valid: boolean;
     inValidTip: string;
-    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
     id?: string | undefined;
     title?: string | undefined;
 }, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
-    required: boolean;
     text: string;
+    required: boolean;
+    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
     valid: boolean;
     inValidTip: string;
-    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
     id?: string | undefined;
     title?: string | undefined;
 }> & Readonly<{}>, {
-    required: boolean;
     text: string;
+    required: boolean;
+    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
     valid: boolean;
     inValidTip: string;
-    showType: import("../dynamic-form-group/dynamic-form-group.props").FormGroupLabelType;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/dynamic-form/src/composition/use-input-type-resolver.d.ts

@@ -0,0 +1,11 @@
+import { EditorType } from "../types";
+export declare function useInputTypeResolver(): {
+    resolveEditorProps: (editorType: EditorType, resolvedPropsValue: {
+        [key: string]: any;
+    }) => Record<string, any>;
+    resolveEditorType: (type: EditorType) => any;
+    getChangeFunctionName: (type: EditorType) => "" | "onChange" | "onChangeValue" | "onModelValueChanged" | "onValueChange" | "onDatePicked" | "onUpdate:modelValue" | undefined;
+    getClearFunctionName: (type: EditorType) => "onClear" | undefined;
+    getMousedownFunctionName: (type: EditorType) => "onMousedownEvent" | undefined;
+    getMouseupFunctionName: (type: EditorType) => "onMouseupEvent" | undefined;
+};

package/types/dynamic-resolver/index.d.ts

@@ -1,3 +1,4 @@
+import { getPropertyConfigBySchemaForDesigner } from './src/resolver/property-config/property-config-resolver-design';
 export * from './src/types';
 export * from './src/props-resolver';
 export * from './src/common/appearance-resolver';
@@ -11,5 +12,7 @@ export * from './src/event-handler-resolver';
 export * from './src/resolver/schema/schema-resolver';
 export * from './src/resolver/schema/schema-resolver-design';
 export * from './src/update-columns-resolver';
+export * from './src/converter/items-count.converter';
 export { propertyConfigSchemaMap, propertyEffectMap } from './src/resolver/property-config/property-config-resolver';
 export { propertyConfigSchemaMapForDesigner, propertyEffectMapForDesigner } from './src/resolver/property-config/property-config-resolver-design';
+export { getPropertyConfigBySchemaForDesigner };

package/types/dynamic-resolver/src/props-resolver.d.ts

@@ -1,2 +1,4 @@
 import { EffectFunction, MapperFunction, SchemaResolverFunction } from './types';
+import { RegisterContext } from '../../common';
 export declare function createPropsResolver<T extends Record<string, any>>(componentPropsObject: T, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | MapperFunction>, schemaResolver?: SchemaResolverFunction, propertyConfig?: Record<string, any>, propertyEffect?: EffectFunction): (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;
+export declare function getPropsResolverGenerator<T extends Record<string, any>>(componentPropsObject: T, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | MapperFunction>, schemaResolver?: SchemaResolverFunction, propertyConfig?: Record<string, any>, propertyEffect?: EffectFunction): (registerContext: RegisterContext) => (schemaValue?: Record<string, any>, mergeDefaults?: boolean) => Record<string, any>;

package/types/dynamic-resolver/src/resolver/property-config/property-config-resolver-design.d.ts

@@ -1,5 +1,5 @@
 import { EffectFunction } from '../../types';
 declare const propertyConfigSchemaMapForDesigner: Record<string, any>;
 declare const propertyEffectMapForDesigner: Record<string, EffectFunction>;
-declare const getPropertyConfigBySchema: (rawSchema: import("../../../..").ComponentSchema, schemaService: import("../../types").SchemaService, designerItem: any, componentId: string, propertyConfig?: Record<string, any> | undefined) => import("../../../../property-panel").ElementPropertyConfig[], getPropertyConfigByType: (schemaType: string, schemaService: import("../../types").SchemaService, schema?: import("../../../..").ComponentSchema) => import("../../../../property-panel").ElementPropertyConfig[], propertyConverterMap: Map<string, import("../../types").PropertyConverter>;
+declare const getPropertyConfigBySchema: (rawSchema: import("../../../../designer-canvas").ComponentSchema, schemaService: import("../../types").SchemaService, designerItem: any, componentId: string, propertyConfig?: Record<string, any> | undefined) => import("../../../../property-panel").ElementPropertyConfig[], getPropertyConfigByType: (schemaType: string, schemaService: import("../../types").SchemaService, schema?: import("../../../../designer-canvas").ComponentSchema) => import("../../../../property-panel").ElementPropertyConfig[], propertyConverterMap: Map<string, import("../../types").PropertyConverter>;
 export { getPropertyConfigBySchema as getPropertyConfigBySchemaForDesigner, getPropertyConfigByType as getPropertyConfigByTypeForDesigner, propertyConfigSchemaMapForDesigner, propertyConverterMap as propertyConverterMapForDesigner, propertyEffectMapForDesigner };

package/types/dynamic-resolver/src/resolver/property-config/property-config-resolver.d.ts

@@ -1,5 +1,5 @@
 import { EffectFunction } from '../../types';
 declare const propertyConfigSchemaMap: Record<string, any>;
 declare const propertyEffectMap: Record<string, EffectFunction>;
-declare const getPropertyConfigBySchema: (rawSchema: import("../../../..").ComponentSchema, schemaService: import("../../types").SchemaService, designerItem: any, componentId: string, propertyConfig?: Record<string, any> | undefined) => import("../../../../property-panel").ElementPropertyConfig[], getPropertyConfigByType: (schemaType: string, schemaService: import("../../types").SchemaService, schema?: import("../../../..").ComponentSchema) => import("../../../../property-panel").ElementPropertyConfig[], propertyConverterMap: Map<string, import("../../types").PropertyConverter>;
+declare const getPropertyConfigBySchema: (rawSchema: import("../../../../designer-canvas").ComponentSchema, schemaService: import("../../types").SchemaService, designerItem: any, componentId: string, propertyConfig?: Record<string, any> | undefined) => import("../../../../property-panel").ElementPropertyConfig[], getPropertyConfigByType: (schemaType: string, schemaService: import("../../types").SchemaService, schema?: import("../../../../designer-canvas").ComponentSchema) => import("../../../../property-panel").ElementPropertyConfig[], propertyConverterMap: Map<string, import("../../types").PropertyConverter>;
 export { getPropertyConfigBySchema, getPropertyConfigByType, propertyConfigSchemaMap, propertyConverterMap, propertyEffectMap };

package/types/dynamic-resolver/src/resolver/property-config/use-property-config-resolver.d.ts

@@ -1,6 +1,6 @@
+import { ComponentSchema } from '../../../../designer-canvas';
+import { ElementPropertyConfig } from '../../../../property-panel';
 import { EffectFunction, PropertyConverter, SchemaService } from '../../types';
-import { ComponentSchema } from "../../../../designer-canvas/src/types";
-import { ElementPropertyConfig } from "../../../../property-panel/src/composition/entity/property-entity";
 export declare function usePropertyConfigResolver(propertyConfigSchemaMap: Record<string, any>, propertyEffectMap: Record<string, EffectFunction>, resolveSchemaWithDefaultValue: (schemaValue: Record<string, any>) => Record<string, any>): {
     getPropertyConfigBySchema: (rawSchema: ComponentSchema, schemaService: SchemaService, designerItem: any, componentId: string, propertyConfig?: Record<string, any>) => ElementPropertyConfig[];
     getPropertyConfigByType: (schemaType: string, schemaService: SchemaService, schema?: ComponentSchema) => ElementPropertyConfig[];

package/types/dynamic-resolver/src/resolver/schema/schema-resolver-design.d.ts

@@ -1,5 +1,5 @@
 import { SchemaResolverFunction } from "../../types";
 declare const schemaMapForDesigner: Record<string, any>;
 declare const schemaResolverMapForDesigner: Record<string, SchemaResolverFunction>;
-declare const getSchemaByType: (componentType: string, resolveContext?: Record<string, any>, designerHostService?: import("../../../..").DesignerHostService | undefined) => Record<string, any> | null, resolveSchemaWithDefaultValue: (schemaValue: Record<string, any>) => Record<string, any>, resolveSchemaToProps: (schemaValue: Record<string, any>, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, mappingSchemaToProps: (resolvedSchema: Record<string, any>, schemaMapper: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, setDesignerContext: (designerContext1: any) => void;
+declare const getSchemaByType: (componentType: string, resolveContext?: Record<string, any>, designerHostService?: import("../../../../designer-canvas").DesignerHostService | undefined) => Record<string, any> | null, resolveSchemaWithDefaultValue: (schemaValue: Record<string, any>) => Record<string, any>, resolveSchemaToProps: (schemaValue: Record<string, any>, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, mappingSchemaToProps: (resolvedSchema: Record<string, any>, schemaMapper: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, setDesignerContext: (designerContext1: any) => void;
 export { getSchemaByType as getSchemaByTypeForDesigner, resolveSchemaWithDefaultValue as resolveSchemaWithDefaultValueForDesigner, resolveSchemaToProps as resolveSchemaToPropsForDesigner, schemaMapForDesigner, schemaResolverMapForDesigner, mappingSchemaToProps as mappingSchemaToPropsForDesigner, setDesignerContext as setDesignerContextForDesigner };

package/types/dynamic-resolver/src/resolver/schema/schema-resolver.d.ts

@@ -1,5 +1,5 @@
 import { SchemaResolverFunction } from "../../types";
 declare const schemaMap: Record<string, any>;
 declare const schemaResolverMap: Record<string, SchemaResolverFunction>;
-declare const getSchemaByType: (componentType: string, resolveContext?: Record<string, any>, designerHostService?: import("../../../..").DesignerHostService | undefined) => Record<string, any> | null, resolveSchemaWithDefaultValue: (schemaValue: Record<string, any>) => Record<string, any>, resolveSchemaToProps: (schemaValue: Record<string, any>, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, mappingSchemaToProps: (resolvedSchema: Record<string, any>, schemaMapper: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, setDesignerContext: (designerContext1: any) => void;
+declare const getSchemaByType: (componentType: string, resolveContext?: Record<string, any>, designerHostService?: import("../../../../designer-canvas").DesignerHostService | undefined) => Record<string, any> | null, resolveSchemaWithDefaultValue: (schemaValue: Record<string, any>) => Record<string, any>, resolveSchemaToProps: (schemaValue: Record<string, any>, defaultSchema: Record<string, any>, schemaMapper?: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, mappingSchemaToProps: (resolvedSchema: Record<string, any>, schemaMapper: Map<string, string | import("../../types").MapperFunction>) => Record<string, any>, setDesignerContext: (designerContext1: any) => void;
 export { getSchemaByType, resolveSchemaWithDefaultValue, resolveSchemaToProps, schemaMap, schemaResolverMap, mappingSchemaToProps, setDesignerContext };