@farris/ui-vue 1.0.0-beta.5 → 1.0.0

package/types/combo-list/src/composition/use-data-source.d.ts

@@ -0,0 +1,3 @@
+import { ComboListProps } from "../combo-list.props";
+import { UseDataSource } from "./types";
+export declare function useDataSource(props: ComboListProps): UseDataSource;

package/types/combo-list/src/designer/combo-list.design.component.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<Record<string, any>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Record<string, any>>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    [x: string]: any;
+}>;
+export default _default;

package/types/combo-list/src/schema/schema-mapper.d.ts

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

package/types/component/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2020 - present, Inspur Genersoft Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { App } from 'vue';
+import Component from './src/component.component';
+import ComponentDesign from './src/designer/component.design.component';
+export * from './src/component.props';
+export { Component, ComponentDesign };
+declare const _default: {
+    install(app: App): void;
+    register(componentMap: Record<string, any>, propsResolverMap: Record<string, any>): void;
+    registerDesigner(componentMap: Record<string, any>, propsResolverMap: Record<string, any>): void;
+};
+export default _default;

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

@@ -0,0 +1,4 @@
+import { ExtractPropTypes } from 'vue';
+export declare const componentProps: Record<string, any>;
+export type ComponentPropsType = ExtractPropTypes<typeof componentProps>;
+export declare const propsResolver: (schemaValue: Record<string, any>) => Record<string, any>;

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

@@ -0,0 +1,10 @@
+export interface UseDesignerRules {
+    /**
+     * 判断是否可以接收拖拽新增的子级控件
+     */
+    canAccepts(): boolean;
+    /**
+     * 判断当前容器是否是固定的上下文的中间层级
+     */
+    checkIsInFixedContextRules(): boolean;
+}

package/types/component/src/designer/use-designer-rules.d.ts

@@ -0,0 +1,2 @@
+import { UseDesignerRules } from "./types";
+export declare function useDesignerRules(schema: Record<string, any>, parentSchema: Record<string, any>): UseDesignerRules;

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

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

package/types/{date-picker → condition}/index.d.ts

@@ -14,14 +14,10 @@
  * limitations under the License.
  */
 import type { App } from 'vue';
-import DatePickerCalendar from './src/components/calendar/calendar.component';
-export * from './src/components/calendar/calendar.props';
-export * from './src/types/calendar';
-export * from './src/types/common';
-export * from './src/types/date-model';
-export * from './src/types/month';
-export * from './src/types/year';
-export { DatePickerCalendar };
+import ConditionFields from './src/condition-fields.component';
+import ConditionList from './src/condition-list.component';
+export * from './src/condition.props';
+export { ConditionFields, ConditionList };
 declare const _default: {
     install(app: App): void;
 };

package/types/condition/src/composition/condition-value/checkbox-value.d.ts

@@ -0,0 +1,13 @@
+import { EditorType } from "../../../../dynamic-form";
+import { ConditionValue } from "./types";
+export declare class CheckBoxValue implements ConditionValue {
+    editorType: EditorType;
+    value: boolean[];
+    constructor(initialData?: {
+        value: boolean[];
+    });
+    clear(): void;
+    setValue(value: boolean[]): void;
+    getValue(): boolean[];
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/combo-lookup-value.d.ts

@@ -0,0 +1,19 @@
+import { ConditionValue } from "./types";
+import { EditorType } from '../../../../dynamic-form';
+export declare class ComboLookupValue implements ConditionValue {
+    editorType: EditorType;
+    textValue: string;
+    value: string[];
+    valueField: string;
+    constructor(initialData?: {
+        textValue: string;
+        value: string[];
+        valueField: string;
+    });
+    clear(): void;
+    getPropValue(helpItem: any, args: Array<string>): any;
+    getTextValue(textField: string): string;
+    getValue(): string;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/date-picker-value.d.ts

@@ -0,0 +1,25 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+type propsDateValue = {
+    count: null | number;
+    dateType: string;
+    isFirstDay: boolean;
+    isLastDay: boolean;
+    name: string;
+    period: string;
+    text: string;
+};
+export declare class DatePickerValue implements ConditionValue {
+    editorType: EditorType;
+    value: string | propsDateValue | undefined;
+    constructor(initialData?: {
+        value: string | propsDateValue;
+    });
+    setValue(target: {
+        formatted: string | propsDateValue;
+    }): void;
+    getValue(): string | propsDateValue | undefined;
+    isEmpty(): boolean;
+    clear(): void;
+}
+export {};

package/types/condition/src/composition/condition-value/date-range-value.d.ts

@@ -0,0 +1,18 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class DateRangeValue implements ConditionValue {
+    editorType: EditorType;
+    begin: string;
+    end: string;
+    constructor(initialData?: {
+        begin: string;
+        end: string;
+    });
+    clear(): void;
+    getValue(): string;
+    setValue(value: {
+        dataRange: string;
+        delimiter: string;
+    }): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/datetime-picker-value.d.ts

@@ -0,0 +1,13 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class DateTimePickerValue implements ConditionValue {
+    editorType: EditorType;
+    value: string | undefined;
+    constructor(initialData?: {
+        value: string;
+    });
+    clear(): void;
+    getValue(): string | undefined;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/dropdown-value.d.ts

@@ -0,0 +1,18 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class ComboListValue implements ConditionValue {
+    editorType: EditorType;
+    value: any;
+    displayText: string;
+    constructor(initialData?: {
+        value: any;
+        dispalyText: string;
+    });
+    clear(): void;
+    getValue(): string;
+    setValue(data: {
+        value: any[];
+        dispalyText: string;
+    }): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/input-group-value.d.ts

@@ -0,0 +1,21 @@
+import { ConditionValue } from './types';
+import { EditorType } from '../../../../dynamic-form';
+export declare class InputGroupValue implements ConditionValue {
+    editorType: EditorType;
+    value: any[];
+    displayText: string;
+    valueField: string;
+    isInputText: boolean;
+    constructor(initialData?: {
+        value: any[];
+        displayText: string;
+        displayField: string;
+        isInputText: boolean;
+    });
+    clear(): void;
+    getPropValue(item: any, fieldPath: Array<string>): any;
+    getTextValue(targetField: string): string;
+    getValue(): string;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/lookup-value.d.ts

@@ -0,0 +1,21 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class LookupValue implements ConditionValue {
+    editorType: EditorType;
+    textValue: string;
+    value: any[];
+    valueField: string;
+    isInputText: boolean;
+    constructor(initialData?: {
+        textValue: string;
+        value: any;
+        valueField: string;
+        isInputText: boolean;
+    });
+    clear(): void;
+    getPropValue(item: any, fieldPath: Array<string>): any;
+    getTextValue(textField: string): string;
+    getValue(): string;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/month-picker-value.d.ts

@@ -0,0 +1,15 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class MonthPickerValue implements ConditionValue {
+    editorType: EditorType;
+    value: string | undefined;
+    constructor(initialData?: {
+        value: string;
+    });
+    setValue(target: {
+        formatted: string | undefined;
+    }): void;
+    getValue(): string | undefined;
+    clear(): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/month-range-value.d.ts

@@ -0,0 +1,18 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class MonthRangeValue implements ConditionValue {
+    editorType: EditorType;
+    begin: string;
+    end: string;
+    clear(): void;
+    constructor(initialData?: {
+        begin: string;
+        end: string;
+    });
+    getValue(): string;
+    setValue(value: {
+        dataRange: string;
+        delimiter: string;
+    }): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/number-range-value.d.ts

@@ -0,0 +1,21 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class NumberRangeValue implements ConditionValue {
+    editorType: EditorType;
+    begin: number | null;
+    end: number | null;
+    constructor(initialData?: {
+        begin: string | number | null;
+        end: string | number | null;
+    });
+    clear(): void;
+    getValue(): {
+        begin: number | null;
+        end: number | null;
+    };
+    setValue(value: {
+        begin: string | number | null;
+        end: string | number | null;
+    }): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/number-spinner-value.d.ts

@@ -0,0 +1,13 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class NumberSpinnerValue implements ConditionValue {
+    editorType: EditorType;
+    value: number | null | undefined;
+    constructor(initialData?: {
+        value: string;
+    });
+    clear(): void;
+    getValue(): number | null | undefined;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/radio-group-value.d.ts

@@ -0,0 +1,13 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class RadioGroupValue implements ConditionValue {
+    editorType: EditorType;
+    value: any;
+    constructor(initialData?: {
+        value: any;
+    });
+    clear(): void;
+    getValue(): any;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/text-value.d.ts

@@ -0,0 +1,13 @@
+import { EditorType } from '../../../../dynamic-form';
+import { ConditionValue } from "./types";
+export declare class TextValue implements ConditionValue {
+    editorType: EditorType;
+    value: string | undefined;
+    constructor(initialData?: {
+        value: string;
+    });
+    clear(): void;
+    getValue(): string | undefined;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/condition-value/types.d.ts

@@ -0,0 +1,9 @@
+import { EditorType } from '../../../../dynamic-form';
+export interface ConditionValue {
+    clear(): void;
+    editorType: EditorType;
+    value?: any;
+    getValue(): any;
+    setValue(value: any): void;
+    isEmpty(): boolean;
+}

package/types/condition/src/composition/types.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from "vue";
+import { ConditionGroup, FieldConfig, Condition } from "../types";
+import { EditorType } from "../../../dynamic-form";
+import { ConditionValue } from "./condition-value/types";
+export interface UseFieldConfig {
+    convertToSingleControl(configs: FieldConfig[]): FieldConfig[];
+    fields: Ref<FieldConfig[]>;
+    fieldMap: Map<string, FieldConfig>;
+    fieldConditions: Ref<FieldConfig[]>;
+    loadFieldConfigs: (useRangeEditor: boolean) => void;
+    initialConditionValue: (conditions: Condition[]) => Condition[];
+}
+export interface UseCondition {
+    addCondition(): void;
+    changeGroupRelation(targetGroup: ConditionGroup): void;
+    conditionGroupMap: Map<number, ConditionGroup>;
+    getConditions: (conditionGroup: ConditionGroup) => Condition[];
+    group(targetsToGroup: (Condition | ConditionGroup)[]): void;
+    groupParentMap: Map<number, ConditionGroup>;
+    insertConditionTo(preCondtion: Condition): void;
+    loadConditionGroup(conditions: Condition[]): ConditionGroup;
+    refresh(): void;
+    removeCondition(targetToRemove: Condition): void;
+    rootGroup: Ref<ConditionGroup>;
+    unGroup(groupToDisperse: ConditionGroup): void;
+}
+export interface UseConditionValue {
+    createConditionValue: (editorType: EditorType, initialValue?: any) => ConditionValue;
+}
+export interface UseSelection {
+    clear(): void;
+    selectedItems: Ref<Set<number>>;
+    toggleSelect(condition: Condition): void;
+    getSelectedGroupItem(): (Condition | ConditionGroup)[];
+}
+export interface UseCompare {
+    getCompareOperators(condition: Condition): {
+        name: string;
+        value: string;
+    }[];
+}

package/types/condition/src/composition/use-compare.d.ts

@@ -0,0 +1,40 @@
+import { SetupContext } from "vue";
+import { ConditionProps } from "../condition.props";
+import { UseCompare, UseFieldConfig } from "./types";
+declare enum CompareType {
+    Equal = "0",
+    NotEqual = "1",
+    Greater = "2",
+    GreaterOrEqual = "3",
+    Less = "4",
+    LessOrEqual = "5",
+    Like = "6",
+    LikeStartWith = "7",
+    LikeEndWith = "8"
+}
+declare const CompareTypeName: {
+    value: string;
+    name: string;
+}[];
+declare const CompareTypeInEditor: {
+    'button-edit': string[];
+    'check-box': string[];
+    'combo-list': string[];
+    'combo-lookup': string[];
+    'date-picker': string[];
+    'date-range': never[];
+    'datetime-picker': string[];
+    'datetime-range': never[];
+    'month-picker': string[];
+    'month-range': never[];
+    'year-picker': string[];
+    'year-range': never[];
+    'input-group': string[];
+    lookup: string[];
+    'number-range': never[];
+    'number-spinner': string[];
+    'radio-group': string[];
+    text: string[];
+};
+export { CompareType, CompareTypeName, CompareTypeInEditor };
+export declare function useCompare(props: ConditionProps, context: SetupContext, useFieldComposition: UseFieldConfig): UseCompare;

package/types/condition/src/composition/use-condition-value.d.ts

@@ -0,0 +1,2 @@
+import { UseConditionValue } from "./types";
+export declare function useConditionValue(): UseConditionValue;

package/types/condition/src/composition/use-condition.d.ts

@@ -0,0 +1,2 @@
+import { UseCondition } from "./types";
+export declare function useCondition(): UseCondition;

package/types/condition/src/composition/use-field-config.d.ts

@@ -0,0 +1,4 @@
+import { SetupContext } from "vue";
+import { ConditionProps } from "../condition.props";
+import { UseFieldConfig } from "./types";
+export declare function useFieldConfig(props: ConditionProps, context: SetupContext): UseFieldConfig;

package/types/condition/src/composition/use-selection.d.ts

@@ -0,0 +1,4 @@
+import { SetupContext } from "vue";
+import { ConditionProps } from "../condition.props";
+import { UseCondition, UseSelection } from "./types";
+export declare function useSelection(props: ConditionProps, context: SetupContext, useConditionComposition: UseCondition): UseSelection;

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

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2020 - present, Inspur Genersoft Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ExtractPropTypes } from 'vue';
+import { FieldConfig, Condition } from './types';
+export declare const conditionProps: {
+    conditions: {
+        type: {
+            (arrayLength: number): Condition[];
+            (...items: Condition[]): Condition[];
+            new (arrayLength: number): Condition[];
+            new (...items: Condition[]): Condition[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    fields: {
+        type: {
+            (arrayLength: number): FieldConfig[];
+            (...items: FieldConfig[]): FieldConfig[];
+            new (arrayLength: number): FieldConfig[];
+            new (...items: FieldConfig[]): FieldConfig[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    key: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type ConditionProps = ExtractPropTypes<typeof conditionProps>;