@gct-paas/core-web 0.1.4-dev.1 → 0.1.4-dev.11

package/es/modules/gct-form/editor/gct-form-model-select/gct-form-model-select.mjs

@@ -0,0 +1,175 @@
+import { defineComponent, ref, onMounted, createVNode, resolveComponent, isVNode } from 'vue';
+import { useNamespace, t } from '@gct-paas/core';
+import { groupBy } from 'lodash-es';
+import { Form } from 'ant-design-vue';
+import { useGctFormValue } from '../../hooks/use-gct-form-value/use-gct-form-value.mjs';
+import './gct-form-model-select.css';/* empty css                            */
+
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !isVNode(s);
+}
+const modelTypeOptions = [{
+  value: 'entity',
+  label: 'sys.pageDesigner.entity'
+}, {
+  value: 'data',
+  label: 'sys.pageDesigner.data'
+}, {
+  value: 'view',
+  label: 'sys.pageDesigner.view'
+}, {
+  value: 'form',
+  label: 'sys.pageDesigner.form',
+  project: ['eDHR', 'MEDPRO']
+}, {
+  value: 'system',
+  label: 'sys.pageDesigner.system'
+}];
+const GctFormModelSelect = /* @__PURE__ */ defineComponent({
+  name: 'GctFormModelSelect',
+  props: {
+    model: {
+      type: Object,
+      required: true
+    },
+    value: {
+      type: String
+    }
+  },
+  setup(props) {
+    const ns = useNamespace('form-model-select');
+    // 模型标识
+    const val = useGctFormValue();
+    // 模型分类
+    const category = useGctFormValue('category');
+    // 模型分类
+    const categorySelect = useGctFormValue('categorySelect');
+    // 模型名称
+    const modelName = useGctFormValue('modelName');
+    // 表单模型id
+    const formId = useGctFormValue('formId');
+    // 模型清单
+    const modelOptions = ref([]);
+    // 模型选择分组清单
+    const modelGroup = ref({});
+    // 模型数据加载
+    const loadModel = async () => {
+      if (categorySelect.value === 'system') {
+        modelOptions.value = (await _api.apaas.report.getListSystemModels()) || [];
+        return {
+          [t('sys.pageDesigner.system')]: modelOptions.value
+        };
+      } else {
+        modelOptions.value = (await _api.apaas.modelComprehensive.getModelSummary({
+          type: props.model.props?.modelTypes || 'NDO,BASE,TREE,TRANSACTION,SIGN',
+          category: category.value,
+          report: true
+        })) || [];
+        return groupBy(modelOptions.value, 'group');
+      }
+    };
+    const {
+      onFieldChange
+    } = Form.useInjectFormItemContext();
+    onMounted(async () => {
+      val.value = val.value ? val.value : undefined;
+      category.value = category.value || 'entity';
+      categorySelect.value = categorySelect.value || category.value;
+      modelGroup.value = await loadModel();
+    });
+    const categoryChange = async cat => {
+      category.value = cat;
+      val.value = null;
+      formId.value = undefined;
+      modelGroup.value = await loadModel();
+    };
+    const modelChange = value => {
+      const item = modelOptions.value.find(item => {
+        if (item.key === value) {
+          return true;
+        }
+        return false;
+      });
+      if (item) {
+        modelName.value = item.name;
+      }
+      if (categorySelect.value === 'system') {
+        category.value = item.modelCategory;
+      }
+      onFieldChange();
+      onSearch();
+    };
+    function onSearch(input) {
+      if (categorySelect.value === 'system') return;
+      {
+        modelGroup.value = groupBy(modelOptions.value, 'group');
+      }
+    }
+    return () => {
+      let _slot2, _slot3;
+      return createVNode("div", {
+        "class": ns.b()
+      }, [createVNode(resolveComponent("a-input-group"), {
+        "compact": true
+      }, {
+        default: () => [createVNode(resolveComponent("a-select"), {
+          "value": categorySelect.value,
+          "onUpdate:value": $event => categorySelect.value = $event,
+          "class": ns.e('class'),
+          "placeholder": "\u8BF7\u9009\u62E9",
+          "onSelect": categoryChange,
+          "disabled": props.model.disabled
+        }, _isSlot(_slot2 = modelTypeOptions.filter(item => {
+          if (props.model.props?.exclude) {
+            return !props.model.props.exclude.includes(item.value) && (!item.project || item.project && _gct.store.appInfo.suiteKey && item.project.includes(_gct.store.appInfo.suiteKey));
+          }
+          if (item.project) {
+            return _gct.store.appInfo.suiteKey && item.project.includes(_gct.store.appInfo.suiteKey);
+          }
+          return true;
+        }).map(item => {
+          let _slot;
+          return createVNode(resolveComponent("a-select-option"), {
+            "key": item.value,
+            "value": item.value
+          }, _isSlot(_slot = t(item.label)) ? _slot : {
+            default: () => [_slot]
+          });
+        })) ? _slot2 : {
+          default: () => [_slot2]
+        }), createVNode(resolveComponent("a-select"), {
+          "value": val.value,
+          "onUpdate:value": $event => val.value = $event,
+          "class": ns.e('model'),
+          "onSelect": modelChange,
+          "show-search": true,
+          "placeholder": "\u8BF7\u9009\u62E9",
+          "disabled": props.model.disabled,
+          "filterOption": (input, option) => {
+            return (option.label || option.name).toLowerCase().indexOf(input.toLowerCase()) >= 0;
+          }
+        }, _isSlot(_slot3 = Object.keys(modelGroup.value).map(group => {
+          const items = modelGroup.value[group].map(item => {
+            return createVNode(resolveComponent("a-select-option"), {
+              "key": item.key,
+              "value": item.key,
+              "label": item.name
+            }, {
+              default: () => [item.name]
+            });
+          });
+          return createVNode(resolveComponent("a-select-opt-group"), {
+            "key": group,
+            "label": group
+          }, _isSlot(items) ? items : {
+            default: () => [items]
+          });
+        })) ? _slot3 : {
+          default: () => [_slot3]
+        })]
+      })]);
+    };
+  }
+});
+
+export { GctFormModelSelect };

package/es/modules/gct-form/editor/gct-form-model-select/index.d.ts

@@ -0,0 +1,8 @@
+import { IEditorProvider } from '../../interface';
+export declare class Provider implements IEditorProvider {
+    component: string;
+}
+declare const _default: {
+    install(app: import('vue').App): void;
+};
+export default _default;

package/es/modules/gct-form/editor/gct-form-model-select/index.mjs

@@ -0,0 +1,14 @@
+import { EditorType } from '../../constants/editor-type/editor-type.mjs';
+import { widthEditorInstall } from '../../utils/width-install/width-install.mjs';
+import { GctFormModelSelect } from './gct-form-model-select.mjs';
+
+class Provider {
+  component = "gct-form-model-select";
+}
+const GctFromModelSelect = widthEditorInstall(
+  EditorType.MODEL_SELECT,
+  () => new Provider(),
+  GctFormModelSelect
+);
+
+export { Provider, GctFromModelSelect as default };

package/es/modules/gct-form/editor/gct-form-multiple-choice/gct-form-multiple-choice.d.ts

@@ -0,0 +1,68 @@
+import { PropType } from 'vue';
+import { IFormItemController, IMPickerEditor } from '../../interface';
+export declare const GctFormMultipleChoice: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    c: {
+        type: PropType<IFormItemController>;
+        required: true;
+    };
+    model: {
+        type: PropType<IMPickerEditor>;
+        required: true;
+    };
+    value: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+}>, {
+    ns: import('@gct-paas/core').Namespace;
+    rootRef: import('vue').Ref<any, any>;
+    val: import('vue').WritableComputedRef<string[], unknown>;
+    loadOptions: () => Promise<import('@gct-paas/core').IDictionaryItem[]>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:value"[], "update:value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    c: {
+        type: PropType<IFormItemController>;
+        required: true;
+    };
+    model: {
+        type: PropType<IMPickerEditor>;
+        required: true;
+    };
+    value: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+}>> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    value: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/modules/gct-form/editor/gct-form-multiple-choice/gct-form-multiple-choice.mjs

@@ -0,0 +1,68 @@
+import { defineComponent, createVNode, resolveComponent, mergeProps, ref, computed } from 'vue';
+import { useNamespace } from '@gct-paas/core';
+
+const GctFormMultipleChoice = /* @__PURE__ */ defineComponent({
+  name: 'GctFormMultipleChoice',
+  props: {
+    c: {
+      type: Object,
+      required: true
+    },
+    model: {
+      type: Object,
+      required: true
+    },
+    value: {
+      type: Array,
+      default: null
+    }
+  },
+  emits: ['update:value'],
+  setup(props, {
+    emit
+  }) {
+    const ns = useNamespace('form-multiple-choice');
+    const rootRef = ref();
+    const val = computed({
+      get: () => {
+        return props.value ?? [];
+      },
+      set: newVal => {
+        emit('update:value', newVal);
+      }
+    });
+    const loadOptions = () => {
+      return props.c.loadDictionary({}, props.model.force);
+    };
+
+    // 初始化有值时直接加载选项
+    if (val.value != null) {
+      props.c.loadDictionary();
+    }
+    return {
+      ns,
+      rootRef,
+      val,
+      loadOptions
+    };
+  },
+  render() {
+    return createVNode("div", {
+      "ref": "rootRef",
+      "class": this.ns.b()
+    }, [createVNode(resolveComponent("a-select"), mergeProps({
+      "value": this.val,
+      "onUpdate:value": $event => this.val = $event,
+      "mode": "multiple",
+      "max-tag-count": 5,
+      "disabled": this.c.state.disabled,
+      "loading": this.c.state.loading,
+      "options": this.c.state.options,
+      "placeholder": this.model.placeholder,
+      "onDropdownVisibleChange": this.loadOptions,
+      "getPopupContainer": () => this.rootRef
+    }, this.model.props || {}), null)]);
+  }
+});
+
+export { GctFormMultipleChoice };

package/es/modules/gct-form/editor/gct-form-multiple-choice/index.d.ts

@@ -0,0 +1,8 @@
+import { IEditorProvider } from '../../interface';
+export declare class provider implements IEditorProvider {
+    component: string;
+}
+declare const _default: {
+    install(app: import('vue').App): void;
+};
+export default _default;

package/es/modules/gct-form/editor/gct-form-multiple-choice/index.mjs

@@ -0,0 +1,14 @@
+import { EditorType } from '../../constants/editor-type/editor-type.mjs';
+import { widthEditorInstall } from '../../utils/width-install/width-install.mjs';
+import { GctFormMultipleChoice as GctFormMultipleChoice$1 } from './gct-form-multiple-choice.mjs';
+
+class provider {
+  component = "GctFormMultipleChoice";
+}
+const GctFormMultipleChoice = widthEditorInstall(
+  EditorType.MULTIPLE_CHOICE,
+  () => new provider(),
+  GctFormMultipleChoice$1
+);
+
+export { GctFormMultipleChoice as default, provider };

package/es/modules/gct-form/editor/gct-form-number/gct-form-number.d.ts

@@ -0,0 +1,28 @@
+import { PropType } from 'vue';
+import { INumberEditor } from '../../interface';
+export declare const GctFormNumber: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    model: {
+        type: PropType<INumberEditor>;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    ns: import('@gct-paas/core').Namespace;
+    val: import('vue').WritableComputedRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:value"[], "update:value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    model: {
+        type: PropType<INumberEditor>;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    value: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/modules/gct-form/editor/gct-form-number/gct-form-number.mjs

@@ -0,0 +1,44 @@
+import { defineComponent, createVNode, resolveComponent, mergeProps } from 'vue';
+import { useNamespace } from '@gct-paas/core';
+import { useGctFormValue } from '../../hooks/use-gct-form-value/use-gct-form-value.mjs';
+
+const GctFormNumber = /* @__PURE__ */ defineComponent({
+  name: 'GctFormNumber',
+  props: {
+    model: {
+      type: Object,
+      required: true
+    },
+    value: {
+      type: String,
+      default: ''
+    }
+  },
+  emits: ['update:value'],
+  setup() {
+    const ns = useNamespace('gct-form-number');
+    const val = useGctFormValue();
+    return {
+      ns,
+      val
+    };
+  },
+  render() {
+    return createVNode(resolveComponent("a-input-number"), mergeProps({
+      "value": this.val,
+      "onUpdate:value": $event => this.val = $event
+    }, this.model.props || {}, {
+      "class": [this.ns.b(), this.model.class],
+      "prefix": this.model.prefix,
+      "suffix": this.model.suffix,
+      "addonBefore": this.model.addonBefore,
+      "addonAfter": this.model.addonAfter,
+      "placeholder": this.model.placeholder,
+      "max": this.model.max,
+      "min": this.model.min,
+      "precision": this.model.precision
+    }), null);
+  }
+});
+
+export { GctFormNumber };

package/es/modules/gct-form/editor/gct-form-number/gct-form-number.provider.d.ts

@@ -0,0 +1,4 @@
+import { IEditorProvider } from '../../interface';
+export declare class GctFormNumberProvider implements IEditorProvider {
+    component: string;
+}

package/es/modules/gct-form/editor/gct-form-number/gct-form-number.provider.mjs

@@ -0,0 +1,5 @@
+class GctFormNumberProvider {
+  component = "gct-form-number";
+}
+
+export { GctFormNumberProvider };

package/es/modules/gct-form/editor/gct-form-number/index.mjs

@@ -0,0 +1,12 @@
+import { GctFormNumberProvider } from './gct-form-number.provider.mjs';
+import { GctFormNumber as GctFormNumber$1 } from './gct-form-number.mjs';
+import { widthEditorInstall } from '../../utils/width-install/width-install.mjs';
+import { EditorType } from '../../constants/editor-type/editor-type.mjs';
+
+const GctFormNumber = widthEditorInstall(
+  EditorType.NUMBER,
+  () => new GctFormNumberProvider(),
+  GctFormNumber$1
+);
+
+export { GctFormNumber as default };

package/es/modules/gct-form/editor/gct-form-picker/gct-form-picker.d.ts

@@ -0,0 +1,39 @@
+import { PropType } from 'vue';
+import { IFormItemController, IPickerEditor } from '../../interface';
+export declare const GctFormPicker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    c: {
+        type: PropType<IFormItemController>;
+        required: true;
+    };
+    model: {
+        type: PropType<IPickerEditor>;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, {
+    ns: import('@gct-paas/core').Namespace;
+    val: import('vue').WritableComputedRef<any, unknown>;
+    nameVal: import('vue').WritableComputedRef<any, any>;
+    loadOptions: () => Promise<import('@gct-paas/core').IDictionaryItem[]>;
+    onChange: (_val: unknown, data: IObject) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:value"[], "update:value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    c: {
+        type: PropType<IFormItemController>;
+        required: true;
+    };
+    model: {
+        type: PropType<IPickerEditor>;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    value: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/modules/gct-form/editor/gct-form-picker/gct-form-picker.mjs

@@ -0,0 +1,113 @@
+import { defineComponent, createVNode, resolveComponent, mergeProps, computed } from 'vue';
+import { useNamespace } from '@gct-paas/core';
+import { useForm } from '../../hooks/use-form/use-form.mjs';
+
+const GctFormPicker = /* @__PURE__ */ defineComponent({
+  name: 'GctFormPicker',
+  props: {
+    c: {
+      type: Object,
+      required: true
+    },
+    model: {
+      type: Object,
+      required: true
+    },
+    value: {
+      type: String,
+      default: null
+    }
+  },
+  emits: ['update:value'],
+  setup(props, {
+    emit
+  }) {
+    const ns = useNamespace('gct-form-picker');
+    const formC = useForm();
+    const nameVal = computed({
+      get() {
+        if (props.model.nameField) {
+          return formC.item[props.model.nameField].value;
+        }
+        return '';
+      },
+      set(v) {
+        if (props.model.nameField) {
+          return formC.item[props.model.nameField].editorValue = v;
+        }
+      }
+    });
+    const val = computed({
+      get: () => {
+        const opt = props.c.state.options.find(_ => {
+          return _.value === props.value;
+        });
+        if (!opt && nameVal.value) {
+          return nameVal.value;
+        }
+        return props.value;
+      },
+      set: newVal => {
+        if (typeof newVal === 'string') {
+          newVal = newVal.trim();
+        }
+        if (typeof newVal != 'object' && props.value == newVal) {
+          return;
+        }
+        const item = props.c.state.options.find(_ => {
+          return _.value === newVal;
+        });
+        if (item && item.data && props.model.fieldMap) {
+          props.model.fieldMap.map(key => {
+            const [key1, key2] = key.split(':');
+            if (key2) {
+              formC.item[key2].editorValue = item.data[key1];
+            }
+          });
+        }
+        emit('update:value', newVal);
+      }
+    });
+    const loadOptions = () => {
+      return props.c.loadDictionary();
+    };
+
+    // 初始化有值时直接加载选项
+    if (val.value != null) {
+      props.c.loadDictionary();
+    }
+    const onChange = (_val, data) => {
+      nameVal.value = data.label;
+    };
+    return {
+      ns,
+      val,
+      nameVal,
+      loadOptions,
+      onChange
+    };
+  },
+  render() {
+    return createVNode(resolveComponent("a-select"), mergeProps({
+      "value": this.val,
+      "onUpdate:value": $event => this.val = $event
+    }, this.model.props || {}, {
+      "class": this.ns.b(),
+      "disabled": this.c.state.disabled,
+      "loading": this.c.state.loading,
+      "options": this.c.state.options,
+      "placeholder": this.model.placeholder,
+      "onDropdownVisibleChange": this.loadOptions,
+      "onChange": this.onChange,
+      "show-search": true,
+      "filter-option": (input, option) => {
+        if (option.label) {
+          return option.label.toLowerCase().indexOf(input.toLowerCase()) >= 0;
+        }
+        return false;
+      }
+    }), null);
+  }
+});
+
+export { GctFormPicker };

package/es/modules/gct-form/editor/gct-form-picker/gct-form-picker.provider.d.ts

@@ -0,0 +1,13 @@
+import { IEditorProvider } from '../../interface';
+/**
+ * 数据选择器编辑器
+ *
+ * @author zhanghanrui
+ * @date 2024-03-27 10:03:03
+ * @export
+ * @class GctFormPickerProvider
+ * @implements {IEditorProvider}
+ */
+export declare class GctFormPickerProvider implements IEditorProvider {
+    component: string;
+}

package/es/modules/gct-form/editor/gct-form-picker/gct-form-picker.provider.mjs

@@ -0,0 +1,5 @@
+class GctFormPickerProvider {
+  component = "gct-form-picker";
+}
+
+export { GctFormPickerProvider };

package/es/modules/gct-form/editor/gct-form-picker/index.mjs

@@ -0,0 +1,12 @@
+import { GctFormPickerProvider } from './gct-form-picker.provider.mjs';
+import { GctFormPicker as GctFormPicker$1 } from './gct-form-picker.mjs';
+import { widthEditorInstall } from '../../utils/width-install/width-install.mjs';
+import { EditorType } from '../../constants/editor-type/editor-type.mjs';
+
+const GctFormPicker = widthEditorInstall(
+  EditorType.PICKER,
+  () => new GctFormPickerProvider(),
+  GctFormPicker$1
+);
+
+export { GctFormPicker as default };