cnhis-design-vue 3.1.9-beta.1 → 3.1.9-beta.4

package/es/packages/form-render/src/constants/index.mjs

@@ -1,6 +1,8 @@
 const InjectAsyncQueue = Symbol("InjectAsyncQueue");
 const InjectionSchemaField = Symbol("InjectionSchemaField");
 const InjectionBusinessCollector = Symbol("InjectionBusinessCollector");
+const InjectionChangeContextCollector = Symbol("InjectionChangeContextCollector");
+const InjectionFormItemDepsCollector = Symbol("InjectionFormItemDepsCollector");
 var FIELD_BUSINESS_TYPE = /* @__PURE__ */ ((FIELD_BUSINESS_TYPE2) => {
   FIELD_BUSINESS_TYPE2["PASSWORD"] = "password";
   FIELD_BUSINESS_TYPE2["ID_CARD"] = "id_card";
@@ -23,4 +25,4 @@ var FIELD_SEX_VALUE = /* @__PURE__ */ ((FIELD_SEX_VALUE2) => {
   return FIELD_SEX_VALUE2;
 })(FIELD_SEX_VALUE || {});
 
-export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, InjectAsyncQueue, InjectionBusinessCollector, InjectionSchemaField };
+export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, InjectAsyncQueue, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionSchemaField };

package/es/packages/form-render/src/hooks/index.d.ts

@@ -1,9 +1,11 @@
-export * from "./useFieldList2Schema";
-export * from "./useFormRequest";
-export * from "./useCommonLog";
-export * from "./useFormField";
-export * from "./useAsyncQueue";
-export * from "./useFieldVisitor";
-export * from "./useTypeNormalize";
-export * from "./useFormValidator";
-export * from "./useBusinessBinding";
+export * from './useFieldList2Schema';
+export * from './useFormRequest';
+export * from './useCommonLog';
+export * from './useFormField';
+export * from './useAsyncQueue';
+export * from './useFieldVisitor';
+export * from './useTypeNormalize';
+export * from './useFormValidator';
+export * from './useBusinessBinding';
+export * from './useChangeContext';
+export * from './useFormItemDeps';

package/es/packages/form-render/src/hooks/index.mjs

@@ -7,3 +7,5 @@ export { useFieldVisitor } from './useFieldVisitor.mjs';
 export { useTypeNormalize } from './useTypeNormalize.mjs';
 export { useFormValidator } from './useFormValidator.mjs';
 export { BusinessCollector, useBusinessBinding } from './useBusinessBinding.mjs';
+export { ContextCollector, useChangeContext } from './useChangeContext.mjs';
+export { FormItemDepsCollector, useFormItemDeps } from './useFormItemDeps.mjs';

package/es/packages/form-render/src/hooks/useAsyncQueue.d.ts

@@ -1,27 +1,7 @@
-import { FormAsyncQueueItem } from "../types";
-declare enum ENTRY_STATE {
-    PENDING = 0,
-    DONE = 1
-}
+import { FormAsyncQueueItem } from '../types';
 interface EntryCallback {
     (err?: any, result?: any): void;
 }
-declare class AsyncQueueEntry<K = any> {
-    key: K;
-    item: any;
-    state: ENTRY_STATE;
-    callback?: EntryCallback;
-    callbacks?: EntryCallback[];
-    result?: any;
-    error?: any;
-    constructor(item: any, key: K, callback: EntryCallback);
-}
-declare class ArrayQueue<K = any> {
-    _list: AsyncQueueEntry<K>[];
-    constructor(items?: AsyncQueueEntry<K>[]);
-    enqueue(item: AsyncQueueEntry<K>): void;
-    dequeue(): AsyncQueueEntry<K> | undefined;
-}
 interface Processor<T, R = any> {
     (item: T, cb: (err?: any, result?: R) => void, removeCache: () => void): void;
 }
@@ -35,21 +15,21 @@ interface AsyncQueueOptions<T = any, K = any> {
  * @constructor 并发控制器
  */
 export declare class AsyncQueue<T = any, K = any, R = any> {
-    name: string;
-    processor: Processor<T, R>;
-    getKey: AsyncQueueOptions<T, K>["getKey"];
-    parallelism: number;
-    _queued: ArrayQueue<K>;
-    _entries: Map<K, AsyncQueueEntry<K>>;
-    _activeTasks: number;
-    _processingLock: boolean;
-    _stopped: boolean;
+    readonly name: string;
+    private readonly processor;
+    private readonly getKey;
+    private readonly parallelism;
+    private readonly _queued;
+    private readonly _entries;
+    private _activeTasks;
+    private _processingLock;
+    private _stopped;
     constructor({ name, processor, getKey, parallelism }: AsyncQueueOptions<T>);
     add(item: T, callback: EntryCallback): void;
     addAsync(item: T): Promise<R>;
-    _ensureProcessing(): void;
-    _startProcess(entry: AsyncQueueEntry): void;
-    _handlerResult(entry: AsyncQueueEntry, e?: any, r?: any): void;
+    private _ensureProcessing;
+    private _startProcess;
+    private _handlerResult;
 }
 export declare function useAsyncQueue(): {
     create: (parallelism?: number) => AsyncQueue<FormAsyncQueueItem, any, {

package/es/packages/form-render/src/hooks/useBusinessBinding.d.ts

@@ -1,13 +1,15 @@
 import { Form } from '@formily/core';
 import { FIELD_BUSINESS_TYPE } from '../constants';
 export declare class BusinessCollector {
-    typeCollector: Map<FIELD_BUSINESS_TYPE, Set<string>>;
-    fieldNameCollector: Map<string, FIELD_BUSINESS_TYPE>;
+    private readonly typeCollector;
+    private readonly fieldNameCollector;
     collect(type: FIELD_BUSINESS_TYPE, fieldName: string): void;
     getField(type: FIELD_BUSINESS_TYPE): string[];
     getType(fieldName: string): FIELD_BUSINESS_TYPE | undefined;
+    handlerIdCardType(formModel: Form, value: unknown): void;
+    handlerMap: Map<FIELD_BUSINESS_TYPE, (formModel: Form, value: unknown) => void>;
+    trigger(formModel: Form, fieldName: string, value: unknown): void;
 }
 export declare function useBusinessBinding(): {
     create: () => BusinessCollector;
-    trigger: (collector: BusinessCollector, formModel: Form, fieldName: string, value: unknown) => void;
 };

package/es/packages/form-render/src/hooks/useBusinessBinding.mjs

@@ -6,6 +6,7 @@ class BusinessCollector {
   constructor() {
     this.typeCollector = /* @__PURE__ */ new Map();
     this.fieldNameCollector = /* @__PURE__ */ new Map();
+    this.handlerMap = /* @__PURE__ */ new Map([[FIELD_BUSINESS_TYPE.ID_CARD, this.handlerIdCardType.bind(this)]]);
   }
   collect(type, fieldName) {
     const set = this.typeCollector.get(type) || /* @__PURE__ */ new Set();
@@ -19,42 +20,41 @@ class BusinessCollector {
   getType(fieldName) {
     return this.fieldNameCollector.get(fieldName);
   }
-}
-function useBusinessBinding() {
-  function create() {
-    return new BusinessCollector();
-  }
-  function handlerIdCardType(formModel, collector, value) {
+  handlerIdCardType(formModel, value) {
     if (!value || !isString(value) || !isIdCard(value))
       return;
     const info = parseIdCard(value);
-    const ageFields = collector.getField(FIELD_BUSINESS_TYPE.AGE);
+    const ageFields = this.getField(FIELD_BUSINESS_TYPE.AGE);
     ageFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.age;
       });
     });
-    const sexFields = collector.getField(FIELD_BUSINESS_TYPE.SEX);
+    const sexFields = this.getField(FIELD_BUSINESS_TYPE.SEX);
     sexFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.sex;
       });
     });
-    const birthdayFields = collector.getField(FIELD_BUSINESS_TYPE.BIRTHDAY);
+    const birthdayFields = this.getField(FIELD_BUSINESS_TYPE.BIRTHDAY);
     birthdayFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.birthday;
       });
     });
   }
-  const handlerMap = /* @__PURE__ */ new Map([[FIELD_BUSINESS_TYPE.ID_CARD, handlerIdCardType]]);
-  function trigger(collector, formModel, fieldName, value) {
-    const type = collector.fieldNameCollector.get(fieldName);
-    if (!type || !handlerMap.has(type))
+  trigger(formModel, fieldName, value) {
+    const type = this.getType(fieldName);
+    if (!type || !this.handlerMap.has(type))
       return;
-    handlerMap.get(type)(formModel, collector, value);
+    this.handlerMap.get(type)(formModel, value);
+  }
+}
+function useBusinessBinding() {
+  function create() {
+    return new BusinessCollector();
   }
-  return { create, trigger };
+  return { create };
 }
 
 export { BusinessCollector, useBusinessBinding };

package/es/packages/form-render/src/hooks/useChangeContext.d.ts

@@ -0,0 +1,11 @@
+import { FormChangeContext } from 'cnhis-design-vue/es/packages/form-render';
+export declare class ContextCollector {
+    private readonly contextMap;
+    setContext(key: string, prop: keyof FormChangeContext, value: any): void;
+    getContext(key: string): Partial<{
+        currentOption: import("../../../../src/types").AnyObject;
+    }>;
+}
+export declare function useChangeContext(): {
+    create: () => ContextCollector;
+};

package/es/packages/form-render/src/hooks/useChangeContext.mjs

@@ -0,0 +1,21 @@
+class ContextCollector {
+  constructor() {
+    this.contextMap = /* @__PURE__ */ new Map();
+  }
+  setContext(key, prop, value) {
+    const context = this.contextMap.get(key) || {};
+    Reflect.set(context, prop, value);
+    this.contextMap.set(key, context);
+  }
+  getContext(key) {
+    return this.contextMap.get(key) || {};
+  }
+}
+function useChangeContext() {
+  function create() {
+    return new ContextCollector();
+  }
+  return { create };
+}
+
+export { ContextCollector, useChangeContext };

package/es/packages/form-render/src/hooks/useFormField.d.ts

@@ -1,4 +1,5 @@
 export declare function useFormField(): {
     field: import("vue").Ref<import("@formily/core").GeneralField>;
     title: import("vue").ComputedRef<any>;
+    fieldKey: import("vue").ComputedRef<string>;
 };

package/es/packages/form-render/src/hooks/useFormField.mjs

@@ -3,7 +3,13 @@ import { computed } from 'vue';
 
 function useFormField() {
   const field = useField();
-  return { field, title: computed(() => field.value.title) };
+  return {
+    field,
+    title: computed(() => field.value.title),
+    fieldKey: computed(() => {
+      return field.value.props.name.toString();
+    })
+  };
 }
 
 export { useFormField };

package/es/packages/form-render/src/hooks/useFormItemDeps.d.ts

@@ -0,0 +1,8 @@
+export declare class FormItemDepsCollector {
+    private readonly collector;
+    setDeps(key: string, dependKey: string | string[], callback: Function): void;
+    trigger(dependKey: string): void;
+}
+export declare function useFormItemDeps(): {
+    create: () => FormItemDepsCollector;
+};

package/es/packages/form-render/src/hooks/useFormItemDeps.mjs

@@ -0,0 +1,29 @@
+import { arrayed } from 'cnhis-design-vue/es/packages/form-render/src/utils';
+
+class FormItemDepsCollector {
+  constructor() {
+    this.collector = /* @__PURE__ */ new Map();
+  }
+  setDeps(key, dependKey, callback) {
+    dependKey = arrayed(dependKey);
+    dependKey.forEach((dependKey2) => {
+      const map = this.collector.get(dependKey2) || /* @__PURE__ */ new Map();
+      map.set(key, callback);
+      this.collector.set(dependKey2, map);
+    });
+  }
+  trigger(dependKey) {
+    const map = this.collector.get(dependKey);
+    map && map.forEach((cb) => {
+      typeof cb === "function" && cb();
+    });
+  }
+}
+function useFormItemDeps() {
+  function create() {
+    return new FormItemDepsCollector();
+  }
+  return { create };
+}
+
+export { FormItemDepsCollector, useFormItemDeps };

package/es/packages/form-render/src/types/index.d.ts

@@ -1,8 +1,8 @@
 import { AnyObject } from 'cnhis-design-vue/es/src/types';
-import { Field } from "@formily/core";
-import { FieldItem } from "../types";
-import { AsyncQueue } from "../hooks";
-export * from "./fieldItem";
+import { DataField, Field } from '@formily/core';
+import { FieldItem } from '../types';
+import { AsyncQueue } from '../hooks';
+export * from './fieldItem';
 export interface FieldVisitorContext {
     field: FieldItem;
     replace(f: FieldItem): void;
@@ -10,7 +10,7 @@ export interface FieldVisitorContext {
     insertAfter(f: FieldItem | FieldItem[]): void;
 }
 export declare type FieldVisitor = Record<string, (context: FieldVisitorContext) => void>;
-export declare type FormRequestType = "post" | "get" | "patch" | "delete" | "put";
+export declare type FormRequestType = 'post' | 'get' | 'patch' | 'delete' | 'put';
 export interface FormAsyncQueueItem {
     key: any;
     url: string;
@@ -18,9 +18,19 @@ export interface FormAsyncQueueItem {
     params?: AnyObject;
 }
 export declare type FormAsyncQueue = AsyncQueue<FormAsyncQueueItem, any, AnyObject[]>;
-export declare type IdCardParseInfo = Record<"sex" | "birthday", string> & Record<"age" | "day" | "month" | "year", number>;
+export declare type IdCardParseInfo = Record<'sex' | 'birthday', string> & Record<'age' | 'day' | 'month' | 'year', number>;
 export declare type FormRenderExpose = {
     validate(): Promise<unknown>;
     getFormValues(): AnyObject;
     setFieldState(path: string, setter: (field: Field) => void): void;
 };
+export declare type FormChangeContext = Partial<{
+    currentOption: AnyObject;
+}>;
+export declare type FormChangePayload = {
+    value: any;
+    fieldKey: string;
+    fieldName: string;
+    fieldInstance: DataField;
+    context: FormChangeContext;
+};

package/es/packages/form-render/src/utils/index.d.ts

@@ -1,6 +1,7 @@
-import { GeneralField } from "@formily/core";
-import { InjectionKey } from "vue";
-import { IdCardParseInfo } from "../types";
+import { AnyObject } from 'cnhis-design-vue/es/src/types';
+import { GeneralField } from '@formily/core';
+import { InjectionKey } from 'vue';
+import { IdCardParseInfo } from '../types';
 export declare function formRenderLog(message: string, type?: keyof Console): void;
 export declare function arrayed<T>(maybeArray: T): T extends Array<any> ? T : [T];
 export declare function assignUpdateValue(props: any, field: GeneralField): any;
@@ -8,3 +9,4 @@ export declare function transformDateFormat(format: string): "date" | "datetime"
 export declare function isIdCard(idCardNo: string): boolean;
 export declare function parseIdCard(idCardNo: string): IdCardParseInfo;
 export declare function injectOrProvide<T>(key: InjectionKey<T>, creator: () => T): T;
+export declare function generateUrlParams(field: GeneralField, dependKeys?: string | string[]): AnyObject;

package/es/packages/form-render/src/utils/index.mjs

@@ -55,5 +55,17 @@ function injectOrProvide(key, creator) {
   }
   return injected;
 }
+function generateUrlParams(field, dependKeys) {
+  const result = {};
+  if (dependKeys) {
+    arrayed(dependKeys).forEach((dependKey) => {
+      const _field = field.query(dependKey).take();
+      if (isField(_field)) {
+        result[dependKey] = _field.value;
+      }
+    });
+  }
+  return result;
+}
 
-export { arrayed, assignUpdateValue, formRenderLog, injectOrProvide, isIdCard, parseIdCard, transformDateFormat };
+export { arrayed, assignUpdateValue, formRenderLog, generateUrlParams, injectOrProvide, isIdCard, parseIdCard, transformDateFormat };