@oinone/kunlun-event 6.2.0

package/src/helper.ts

@@ -0,0 +1,31 @@
+const isType = <T>(type: string | string[]) => (obj: unknown): obj is T => getType(obj) === `[object ${type}]`;
+const getType = (obj: any) => Object.prototype.toString.call(obj);
+const isFn = (val: any): val is Function => typeof val === 'function';
+const isArr = Array.isArray;
+const isPlainObj = isType<object>('Object');
+const isStr = isType<string>('String');
+const isBool = isType<boolean>('Boolean');
+const isNum = isType<number>('Number');
+const isMap = (val: any): val is Map<any, any> => val && val instanceof Map;
+const isSet = (val: any): val is Set<any> => val && val instanceof Set;
+const isWeakMap = (val: any): val is WeakMap<any, any> => val && val instanceof WeakMap;
+const isWeakSet = (val: any): val is WeakSet<any> => val && val instanceof WeakSet;
+const isNumberLike = (index: any): index is number => isNum(index) || /^\d+$/.test(index);
+const isObj = (val: unknown): val is object => typeof val === 'object';
+const isRegExp = isType<RegExp>('RegExp');
+
+export {
+  isFn,
+  isArr,
+  isPlainObj,
+  isStr,
+  isBool,
+  isNum,
+  isMap,
+  isSet,
+  isWeakMap,
+  isWeakSet,
+  isNumberLike,
+  isObj,
+  isRegExp
+};

package/src/html-event/basic/AbstractHTMLEventProducer.ts

@@ -0,0 +1,30 @@
+import { AbstractEventProducer, EventCategoryType, EventMessage, EventProducer, EventProducerOptions } from '../../bus';
+
+export abstract class AbstractHTMLEventProducer<
+  K extends keyof HTMLElementEventMap,
+  EV extends HTMLElementEventMap[K] = HTMLElementEventMap[K]
+> extends AbstractEventProducer<K, HTMLElementEventMap[K]> {
+  protected constructor(
+    category: EventCategoryType,
+    type: K,
+    options?: EventProducerOptions<K, HTMLElementEventMap[K]>
+  ) {
+    super(category, type, options);
+  }
+
+  protected $$convert(self: EventProducer<K, EV>, ev: EV): EventMessage<EV> | undefined {
+    return {
+      category: this.category,
+      type: this.type,
+      origin: ev
+    };
+  }
+
+  protected $$start() {
+    document.addEventListener(this.type, this.publish.bind(this));
+  }
+
+  protected $$stop() {
+    document.removeEventListener(this.type, this.publish.bind(this));
+  }
+}

package/src/html-event/basic/HTMLEventConsumer.ts

@@ -0,0 +1,26 @@
+import {
+  AbstractEventConsumer,
+  EventCategory,
+  EventConsumerConfig,
+  EventConsumerConstructor,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventMessage,
+  registerEventConsumer
+} from '../../bus';
+
+export class HTMLEventConsumer<
+  K extends keyof HTMLElementEventMap,
+  M extends EventMessage<HTMLElementEventMap[K]> = EventMessage<HTMLElementEventMap[K]>,
+  C extends EventConsumerConfig = EventConsumerConfig
+> extends AbstractEventConsumer<K, HTMLElementEventMap[K], HTMLElementEventMap[K], M, C> {
+  public constructor(
+    type: K,
+    consumer: EventConsumerFunction<K, HTMLElementEventMap[K], HTMLElementEventMap[K], M, C>,
+    options?: EventConsumerOptions<HTMLElementEventMap[K], HTMLElementEventMap[K], M, C>
+  ) {
+    super(EventCategory.html, type, consumer, options);
+  }
+}
+
+registerEventConsumer({ category: EventCategory.html }, HTMLEventConsumer as EventConsumerConstructor);

package/src/html-event/basic/HTMLEventProducer.ts

@@ -0,0 +1,10 @@
+import { EventCategory, EventProducerConstructor, EventProducerOptions, registerEventProducer } from '../../bus';
+import { AbstractHTMLEventProducer } from './AbstractHTMLEventProducer';
+
+export class HTMLEventProducer<K extends keyof HTMLElementEventMap> extends AbstractHTMLEventProducer<K> {
+  public constructor(type: K, options?: EventProducerOptions<K, HTMLElementEventMap[K]>) {
+    super(EventCategory.html, type, options);
+  }
+}
+
+registerEventProducer({ category: EventCategory.html }, HTMLEventProducer as EventProducerConstructor);

package/src/html-event/basic/index.ts

@@ -0,0 +1,3 @@
+export * from './AbstractHTMLEventProducer';
+export * from './HTMLEventConsumer';
+export * from './HTMLEventProducer';

package/src/html-event/index.ts

@@ -0,0 +1,2 @@
+export * from './basic';
+export * from './keyboard';

package/src/html-event/keyboard/HTMLKeyboardEventConsumer.ts

@@ -0,0 +1,160 @@
+import { useEnv } from '@oinone/kunlun-environment';
+import {
+  AbstractEventConsumer,
+  EventCategory,
+  EventCategoryType,
+  EventConsumerConstructor,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventConsumerScope,
+  HTMLKeyboardEventConsumerConfig,
+  KeyboardEventMessage,
+  KeyboardTypes,
+  registerEventConsumer
+} from '../../bus';
+
+type KeyboardEventConsumerOptions = EventConsumerOptions<
+  KeyboardEvent,
+  KeyboardEvent,
+  KeyboardEventMessage,
+  HTMLKeyboardEventConsumerConfig
+>;
+
+class AbstractKeyboardEventConsumer extends AbstractEventConsumer<
+  string,
+  KeyboardEvent,
+  KeyboardEvent,
+  KeyboardEventMessage,
+  HTMLKeyboardEventConsumerConfig
+> {
+  public constructor(
+    category: EventCategoryType,
+    type: string,
+    consumer: EventConsumerFunction<
+      string,
+      KeyboardEvent,
+      KeyboardEvent,
+      KeyboardEventMessage,
+      HTMLKeyboardEventConsumerConfig
+    >,
+    options?: KeyboardEventConsumerOptions
+  ) {
+    super(category, type, consumer, options);
+    this.initConfig();
+  }
+
+  protected initConfig(): void {
+    const { config } = this;
+    if (config.scope == null) {
+      config.scope = EventConsumerScope.view;
+    }
+    if (config.ctrl === undefined) {
+      config.ctrl = false;
+    }
+    if (config.shift === undefined) {
+      config.shift = false;
+    }
+    if (config.alt === undefined) {
+      config.alt = false;
+    }
+  }
+
+  protected $$filter(ev: KeyboardEvent, message: KeyboardEventMessage) {
+    const { scope, ctrl, alt, shift } = this.config;
+    let isTrigger = false;
+    switch (scope) {
+      case EventConsumerScope.global:
+      case EventConsumerScope.current:
+        isTrigger = true;
+        break;
+      case EventConsumerScope.view: {
+        const { el } = this;
+        if (!el) {
+          break;
+        }
+        const { x: clientX, y: clientY } = el.getBoundingClientRect();
+        const env = useEnv();
+        const clickVisibleArea = env.clickVisibleArea[0];
+        if (clickVisibleArea) {
+          const { el: visibleEl, x, y, ex, ey } = clickVisibleArea;
+          if (visibleEl) {
+            if (visibleEl.contains(el)) {
+              isTrigger = true;
+            }
+          } else if (x <= clientX && clientX <= ex && y <= clientY && clientY <= ey) {
+            isTrigger = true;
+            break;
+          }
+        } else {
+          // fixme @zbh 20241216 此处逻辑无法闭合，暂时不启用
+          // for (const visibleArea of env.visibleArea.values()) {
+          //   const { x, y, ex, ey } = visibleArea;
+          //   if (x <= clientX && clientX <= ex && y <= clientY && clientY <= ey) {
+          //     isTrigger = true;
+          //     break;
+          //   }
+          // }
+          // if (!isTrigger) {
+          //   const { x, y, ex, ey } = env.contentVisibleArea;
+          //   if (x <= clientX && clientX <= ex && y <= clientY && clientY <= ey) {
+          //     isTrigger = true;
+          //     break;
+          //   }
+          // }
+        }
+        break;
+      }
+    }
+    if (!isTrigger) {
+      return false;
+    }
+    if (ctrl != null && ctrl !== message.ctrl) {
+      return false;
+    }
+    if (shift != null && shift !== message.shift) {
+      return false;
+    }
+    if (alt != null && alt !== message.alt) {
+      return false;
+    }
+    return true;
+  }
+}
+
+export class HTMLKeyboardEventConsumer extends AbstractKeyboardEventConsumer {
+  public constructor(
+    type: string,
+    consumer: EventConsumerFunction<
+      string,
+      KeyboardEvent,
+      KeyboardEvent,
+      KeyboardEventMessage,
+      HTMLKeyboardEventConsumerConfig
+    >,
+    options?: KeyboardEventConsumerOptions
+  ) {
+    super(EventCategory.html, type, consumer, options);
+  }
+}
+
+export class KeyboardEventConsumer extends AbstractKeyboardEventConsumer {
+  public constructor(
+    type: string,
+    consumer: EventConsumerFunction<
+      string,
+      KeyboardEvent,
+      KeyboardEvent,
+      KeyboardEventMessage,
+      HTMLKeyboardEventConsumerConfig
+    >,
+    options?: KeyboardEventConsumerOptions
+  ) {
+    super(EventCategory.keyboard, type, consumer, options);
+  }
+}
+
+registerEventConsumer(
+  { category: EventCategory.html, type: KeyboardTypes },
+  HTMLKeyboardEventConsumer as EventConsumerConstructor
+);
+registerEventConsumer({ category: EventCategory.keyboard }, KeyboardEventConsumer as EventConsumerConstructor);

package/src/html-event/keyboard/HTMLKeyboardEventProducer.ts

@@ -0,0 +1,72 @@
+import { KeyboardEventHelper } from '@oinone/kunlun-shared';
+import {
+  EventCategory,
+  EventProducer,
+  EventProducerConstructor,
+  EventProducerOptions,
+  KeyboardEventMessage,
+  KeyboardType,
+  KeyboardTypes,
+  registerEventProducer
+} from '../../bus';
+import { AbstractHTMLEventProducer } from '../basic';
+
+abstract class AbstractHTMLKeyboardEventProducer<K extends KeyboardType> extends AbstractHTMLEventProducer<
+  K,
+  KeyboardEvent
+> {
+  protected $$convert(self: EventProducer<K, KeyboardEvent>, ev: KeyboardEvent): KeyboardEventMessage | undefined {
+    const helper = KeyboardEventHelper.newInstance(ev);
+    if (helper.isStateKey()) {
+      return undefined;
+    }
+    return {
+      category: this.category,
+      type: this.type,
+      origin: ev,
+      code: ev.code,
+      key: ev.key,
+      ctrl: helper.isPressCtrl(),
+      alt: helper.isPressAlt(),
+      shift: helper.isPressShift()
+    };
+  }
+}
+
+export class HTMLKeyboardEventProducer<K extends KeyboardType> extends AbstractHTMLKeyboardEventProducer<K> {
+  public constructor(type: K, options?: EventProducerOptions<K, KeyboardEvent>) {
+    super(EventCategory.html, type, options);
+  }
+}
+
+export class KeyboardEventProducer<K extends KeyboardType> extends AbstractHTMLKeyboardEventProducer<K> {
+  public constructor(type: K, options?: EventProducerOptions<K, KeyboardEvent>) {
+    super(EventCategory.keyboard, type, options);
+  }
+
+  protected $$convert(self: EventProducer<K, KeyboardEvent>, ev: KeyboardEvent): KeyboardEventMessage | undefined {
+    const message = super.$$convert(self, ev);
+    if (message) {
+      message.type = ev.key;
+    }
+    return message;
+  }
+
+  protected onKeydown(ev: KeyboardEvent) {
+    this.publish(ev);
+  }
+
+  protected $$start() {
+    document.addEventListener('keydown', this.onKeydown.bind(this));
+  }
+
+  protected $$stop() {
+    document.removeEventListener('keydown', this.onKeydown.bind(this));
+  }
+}
+
+registerEventProducer(
+  { category: EventCategory.html, type: KeyboardTypes },
+  HTMLKeyboardEventProducer as EventProducerConstructor
+);
+registerEventProducer({ category: EventCategory.keyboard }, KeyboardEventProducer as EventProducerConstructor);

package/src/html-event/keyboard/index.ts

@@ -0,0 +1,2 @@
+export * from './HTMLKeyboardEventConsumer';
+export * from './HTMLKeyboardEventProducer';

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './bus';
+export * from './html-event';
+export * from './effects';
+export * from './lifecycle';
+export * from './helper';
+export * from './typing';

package/src/lifecycle/heart.ts

@@ -0,0 +1,160 @@
+import { isStr } from '../helper';
+import { LifeCycle } from './lifecycle';
+import { LifeCycleTypes, RegistryType } from '../typing';
+
+/**
+ * HeartLifeCycles = [{
+ *  registryType: Field,
+ *  type: onFieldChange,
+ *  pattern: {
+ *    identifier: displayName
+ *    lifes: [LifeCycle]
+ *  }
+ * }]
+ */
+
+type HeartLifeCycles = {
+  type: LifeCycleTypes;
+  registryType: RegistryType;
+  pattern: {
+    identifier: string;
+    lifes: LifeCycle[];
+  }[];
+}[];
+
+/**
+ * 操作生命周期的api
+ */
+class LifeCycleHeart {
+  private static lifeCycles: HeartLifeCycles = [];
+
+  private static heartType: RegistryType | null = null;
+
+  static initialize(lifeCycles: HeartLifeCycles) {
+    this.lifeCycles = lifeCycles;
+  }
+
+  private static getLifeCycleIndex(type: LifeCycleTypes) {
+    return this.lifeCycles.findIndex((l) => l.type === type);
+  }
+
+  static getLifeCycle() {
+    return this.lifeCycles;
+  }
+
+  static getLifeCycleByType(type: LifeCycleTypes) {
+    const index = this.getLifeCycleIndex(type);
+
+    if (index >= 0) {
+      return this.lifeCycles[index];
+    }
+
+    return null;
+  }
+
+  /**
+   * 设置生命周期的注册类型,
+   *
+   * @param {registryType} RegistryType 类型
+   */
+  static setType(registryType: RegistryType) {
+    this.heartType = registryType;
+  }
+
+  /**
+   * 设置生命周期
+   * 调用该函数之前要先调用 `setType` 设置注册类型
+   *
+   * @param {type} LifeCycleTypes 生命周期的类型
+   * @param {identifier} string 唯一标识符
+   * @param {lifeCycle} LifeCycle 生命周期的实例
+   *
+   */
+  static setLifeCycle(type: LifeCycleTypes, identifier: string, lifeCycle: LifeCycle) {
+    if (!isStr(type) || !isStr(identifier) || !(lifeCycle instanceof LifeCycle)) {
+      return false;
+    }
+
+    if (!this.heartType) {
+      throw new Error(`set fail, use "LifeCycleHeart.setType(type)" first, then call "setLifeCycle"`);
+    }
+
+    const index = this.getLifeCycleIndex(type);
+
+    if (index >= 0) {
+      if (identifier) {
+        this.lifeCycles[index].pattern.push({
+          identifier,
+          lifes: [lifeCycle]
+        });
+      }
+    } else {
+      this.lifeCycles.push({
+        type,
+        registryType: this.heartType,
+        pattern: [
+          {
+            identifier,
+            lifes: [lifeCycle]
+          }
+        ]
+      });
+    }
+
+    this.heartType = null;
+  }
+
+  /**
+   * 触发生命周期的回调函数
+   *
+   * @param {type} LifeCycleTypes 生命周期的类型
+   * @param {identifier} string 唯一标识符
+   * @param {ctx} Context 当前「视图/字段/Action」的上下文
+   */
+  static publish<C = any>(type: LifeCycleTypes, identifier: string, ctx: C) {
+    if (!type || !identifier || !ctx) {
+      return false;
+    }
+
+    const index = this.getLifeCycleIndex(type);
+
+    if (index >= 0 && identifier) {
+      const pattern = this.lifeCycles[index].pattern.find((p) => p.identifier === identifier);
+      if (pattern) {
+        pattern.lifes.forEach((l) => {
+          l.notify(ctx);
+        });
+      }
+    }
+  }
+
+  /**
+   * @deprecated 销毁生命周期
+   *
+   * @param {identifier} string 唯一标识符
+   */
+  static disposeLifeCycle(identifier: string) {
+    // this.lifeCycles.forEach((life) => {
+    //   const index = life.pattern.findIndex((l) => l.identifier === identifier);
+    //   if (index >= 0) {
+    //     life.pattern.splice(index, 1);
+    //   }
+    // });
+  }
+
+  /**
+   * 销毁生命周期
+   *
+   * @param {identifier} string 唯一标识符
+   */
+  static dispose(identifier: string) {
+    this.lifeCycles.forEach((life) => {
+      const index = life.pattern.findIndex((l) => l.identifier === identifier);
+      if (index >= 0) {
+        life.pattern.splice(index, 1);
+      }
+    });
+  }
+}
+
+export { LifeCycleHeart };

package/src/lifecycle/index.ts

@@ -0,0 +1,2 @@
+export * from './lifecycle';
+export * from './heart';

package/src/lifecycle/lifecycle.ts

@@ -0,0 +1,29 @@
+import { isFn } from '../helper';
+
+type LifeCyclePayload<Context = any> = (context: Context) => void;
+
+class LifeCycle<Context = any> {
+  private listener!: LifeCyclePayload<Context>;
+
+  constructor(callback?: (ctx: Context) => void) {
+    if (!isFn(callback)) {
+      throw new Error('life cycle callback must be function');
+    }
+
+    this.listener = this.buildListener(callback);
+  }
+
+  private buildListener(callback?: Function): LifeCyclePayload {
+    return (ctx?: Context) => {
+      if (isFn(callback)) {
+        callback(ctx);
+      }
+    };
+  }
+
+  public notify(ctx: Context) {
+    this.listener.call(ctx, ctx);
+  }
+}
+
+export { LifeCycle };

package/src/typing/index.ts

@@ -0,0 +1 @@
+export * from './lifecycle';

package/src/typing/lifecycle.ts

@@ -0,0 +1,104 @@
+export enum RegistryType {
+  FIELD = 'Field',
+  VIEW = 'View',
+  ACTION = 'Action'
+}
+
+export enum LifeCycleTypes {
+  /**
+   * View LifeCycle
+   * */
+
+  ON_VIEW_BEFORE_CREATED = 'onViewBeforeCreated', // 创建之前
+  ON_VIEW_CREATED = 'onViewCreated', // 创建成功
+  ON_VIEW_BEFORE_MOUNT = 'onViewBeforeMount', // 挂载前
+  ON_VIEW_MOUNTED = 'onViewMounted', // 挂载成功
+  ON_VIEW_BEFORE_UPDATE = 'onViewBeforeUpdate', // 修改前
+  ON_VIEW_UPDATED = 'onViewUpdated', // 修改后
+  ON_VIEW_ACTIVATED = 'onViewActivated',
+  ON_VIEW_BEFORE_UNMOUNT = 'onViewBeforeUnmount', // 销毁前
+  ON_VIEW_UNMOUNTED = 'onViewUnmounted', // 销毁
+
+  ON_VIEW_SUBMIT = 'onViewSubmit', // 提交数据
+  ON_VIEW_SUBMIT_START = 'onViewSubmitStart', // 数据提交前
+  ON_VIEW_SUBMIT_END = 'onViewSubmitEnd', // 数据提交后
+  ON_VIEW_SUBMIT_SUCCESS = 'onViewSubmitSuccess', // 数据提交成功
+  ON_VIEW_SUBMIT_FAILED = 'onViewSubmitFailed', // 数据提交失败
+
+  ON_VIEW_VALIDATE_START = 'onViewValidateStart', // 字段校验前
+  ON_VIEW_VALIDATE_SUCCESS = 'onViewValidateSuccess', // 字段校验成功
+  ON_VIEW_VALIDATE_FAILED = 'onViewValidateFailed', // 字段校验失败
+  ON_VIEW_VALIDATE_END = 'onViewValidateEnd', // 字段校验结束
+
+  /**
+   * Field LifeCycle
+   * */
+
+  ON_FIELD_BEFORE_CREATED = 'onFieldBeforeCreated', // 创建之前
+  ON_FIELD_CREATED = 'onFieldCreated', // 创建成功
+  ON_FIELD_BEFORE_MOUNT = 'onFieldBeforeMount', // 挂载前
+  ON_FIELD_MOUNTED = 'onFieldMounted', // 挂载成功
+  ON_FIELD_BEFORE_UPDATE = 'onFieldBeforeUpdate', // 修改前
+  ON_FIELD_UPDATED = 'onFieldUpdated', // 修改后
+  ON_FIELD_ACTIVATED = 'onFieldActivated',
+  ON_FIELD_BEFORE_UNMOUNT = 'onFieldBeforeUnmount', // 销毁前
+  ON_FIELD_UNMOUNTED = 'onFieldUnmounted', // 销毁
+
+  ON_FIELD_FOCUS = 'onFieldFocus', // 字段获取焦点
+  ON_FIELD_CHANGE = 'onFieldChange', // 字段数据发生了改变
+  ON_FIELD_BLUR = 'onFieldBlur', // 字段失焦
+
+  ON_FIELD_VALIDATE_START = 'onFieldValidateStart', // 字段校验前
+  ON_FIELD_VALIDATE_SUCCESS = 'onFieldValidateSuccess', // 字段校验成功
+  ON_FIELD_VALIDATE_FAILED = 'onFieldValidateFailed', // 字段校验失败
+  ON_FIELD_VALIDATE_END = 'onFieldValidateEnd' // 字段校验结束
+}
+
+/**
+ * View internal event
+ */
+export enum ViewEventNames {
+  viewBeforeCreated = LifeCycleTypes.ON_VIEW_BEFORE_CREATED,
+  viewCreated = LifeCycleTypes.ON_VIEW_CREATED,
+  viewBeforeMount = LifeCycleTypes.ON_VIEW_BEFORE_MOUNT,
+  viewMounted = LifeCycleTypes.ON_VIEW_MOUNTED,
+  viewBeforeUpdate = LifeCycleTypes.ON_VIEW_BEFORE_UPDATE,
+  viewUpdated = LifeCycleTypes.ON_VIEW_UPDATED,
+  viewActivated = LifeCycleTypes.ON_VIEW_ACTIVATED,
+  viewBeforeUnmount = LifeCycleTypes.ON_VIEW_BEFORE_UNMOUNT,
+  viewUnmounted = LifeCycleTypes.ON_VIEW_UNMOUNTED,
+  viewSubmit = LifeCycleTypes.ON_VIEW_SUBMIT,
+  viewSubmitStart = LifeCycleTypes.ON_VIEW_SUBMIT_START,
+  viewSubmitEnd = LifeCycleTypes.ON_VIEW_SUBMIT_END,
+  viewSubmitSuccess = LifeCycleTypes.ON_VIEW_SUBMIT_SUCCESS,
+  viewSubmitFailed = LifeCycleTypes.ON_VIEW_SUBMIT_FAILED,
+  viewValidateStart = LifeCycleTypes.ON_VIEW_VALIDATE_START,
+  viewValidateSuccess = LifeCycleTypes.ON_VIEW_VALIDATE_SUCCESS,
+  viewValidateFailed = LifeCycleTypes.ON_VIEW_VALIDATE_FAILED,
+  viewValidateEnd = LifeCycleTypes.ON_VIEW_VALIDATE_END
+}
+
+export type ViewEventName = keyof typeof ViewEventNames;
+
+/**
+ * Field internal event
+ */
+export enum FieldEventNames {
+  beforeCreated = LifeCycleTypes.ON_FIELD_BEFORE_CREATED,
+  created = LifeCycleTypes.ON_FIELD_CREATED,
+  beforeMount = LifeCycleTypes.ON_FIELD_BEFORE_MOUNT,
+  mount = LifeCycleTypes.ON_FIELD_MOUNTED,
+  beforeUpdate = LifeCycleTypes.ON_FIELD_BEFORE_UPDATE,
+  updated = LifeCycleTypes.ON_VIEW_UPDATED,
+  beforeUnmount = LifeCycleTypes.ON_FIELD_BEFORE_UNMOUNT,
+  unmounted = LifeCycleTypes.ON_FIELD_UNMOUNTED,
+  focus = LifeCycleTypes.ON_FIELD_FOCUS,
+  change = LifeCycleTypes.ON_FIELD_CHANGE,
+  blur = LifeCycleTypes.ON_FIELD_BLUR,
+  validateStart = LifeCycleTypes.ON_FIELD_VALIDATE_START,
+  validateSuccess = LifeCycleTypes.ON_FIELD_VALIDATE_SUCCESS,
+  validateFailed = LifeCycleTypes.ON_FIELD_VALIDATE_FAILED,
+  validateEnd = LifeCycleTypes.ON_FIELD_VALIDATE_END
+}
+
+export type FieldEventName = keyof typeof FieldEventNames;