@oinone/kunlun-event 6.2.0

package/src/bus/bus/index.ts

@@ -0,0 +1,46 @@
+import { ConsumerOperator, ProducerOperator } from '../operator';
+import { Basic } from './basic';
+import { HTMLEvent } from './html-event';
+import { HTMLKeyboardEvent } from './html-keyboard-event';
+
+export class EventBus {
+  public static init = Basic.init;
+
+  public static startProducer = Basic.startProducer;
+
+  public static stopProducer = Basic.stopProducer;
+
+  public static publish = Basic.publish;
+
+  public static subscribe = Basic.subscribe;
+
+  public static unsubscribe = Basic.unsubscribe;
+
+  public static start = Basic.startConsumer;
+
+  public static stop = Basic.stopConsumer;
+
+  // public static constructProducer = ProducerOperator.construct;
+
+  // public static initProducer = ProducerOperator.init;
+
+  public static disposeProducer = ProducerOperator.dispose;
+
+  // public static constructConsumer = ConsumerOperator.construct;
+
+  // public static initConsumer = ConsumerOperator.init;
+
+  public static disposeConsumer = ConsumerOperator.dispose;
+
+  // public static initHTMLProducer = HTMLEvent.init;
+
+  // public static disposeHTMLProducer = HTMLEvent.dispose;
+
+  public static subscribeHTMLEvent = HTMLEvent.subscribe;
+
+  // public static initKeyboardProducer = HTMLKeyboardEvent.init;
+
+  // public static disposeKeyboardProducer = HTMLKeyboardEvent.dispose;
+
+  public static subscribeKeyboardEvent = HTMLKeyboardEvent.subscribe;
+}

package/src/bus/hook/consumer.ts

@@ -0,0 +1 @@
+export {};

package/src/bus/hook/index.ts

@@ -0,0 +1,2 @@
+export * from './consumer';
+export * from './producer';

package/src/bus/hook/producer.ts

@@ -0,0 +1 @@
+export {};

package/src/bus/index.ts

@@ -0,0 +1,5 @@
+export * from './abstract';
+export * from './bus';
+export * from './hook';
+export * from './spi';
+export * from './typing';

package/src/bus/operator/consumer.ts

@@ -0,0 +1,83 @@
+import { useCurrentInstance } from '@oinone/kunlun-environment';
+import { instantiate } from '@oinone/kunlun-shared';
+import { selectorEventConsumer } from '../spi';
+import {
+  EventConsumer,
+  EventConsumerConfig,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventEngineOptions,
+  EventMessage
+} from '../typing';
+
+export class ConsumerOperator {
+  private static consumers: Map<string, EventConsumer<unknown, unknown, unknown>[]> = new Map<
+    string,
+    EventConsumer<unknown, unknown, unknown>[]
+  >();
+
+  public static getConsumers(message: EventMessage) {
+    return ConsumerOperator.consumers.get(ConsumerOperator.generatorKeyByMessage(message));
+  }
+
+  public static construct<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(
+    options: EventEngineOptions,
+    consumer: EventConsumerFunction<K, EV, V, M, C>,
+    consumerOptions?: EventConsumerOptions<EV, V, M, C>
+  ): EventConsumer<K, EV, V, M, C> {
+    const ConsumerConstructor = selectorEventConsumer<K, EV, V, M, C>(options);
+    if (!ConsumerConstructor) {
+      throw new Error(`Unsupported consumer. category: ${options.category}, type: ${options.type}`);
+    }
+    const consumerInstance = instantiate(ConsumerConstructor, options.type, consumer, consumerOptions);
+    consumerInstance.el = useCurrentInstance().currentInstance?.vNode.el;
+    return consumerInstance;
+  }
+
+  public static init<K = string, EV = unknown, V = EV>(consumer: EventConsumer<K, EV, V>): void {
+    const key = ConsumerOperator.generatorKeyByEngine(consumer);
+    let consumers = ConsumerOperator.consumers.get(key);
+    if (!consumers) {
+      consumers = [];
+      ConsumerOperator.consumers.set(key, consumers);
+    }
+    consumers.push(consumer);
+    consumer.start();
+  }
+
+  public static dispose<K = string, EV = unknown, V = EV>(consumer: EventConsumer<K, EV, V>): boolean {
+    const gk = ConsumerOperator.generatorKeyByEngine(consumer);
+    const ck = consumer.key;
+    const consumers = ConsumerOperator.consumers.get(gk);
+    if (!consumers) {
+      return false;
+    }
+    const pos = consumers.findIndex((v) => v.key === ck);
+    if (pos === -1) {
+      return false;
+    }
+    const deleteConsumers = consumers.splice(pos, 1);
+    for (const deleteConsumer of deleteConsumers) {
+      deleteConsumer.dispose();
+    }
+    return true;
+  }
+
+  public static generatorKey(category: string, type: string) {
+    return `${category}#${type}`;
+  }
+
+  public static generatorKeyByEngine<K = string, EV = unknown, V = EV>(consumer: EventConsumer<K, EV, V>) {
+    return `${consumer.category}#${consumer.type}`;
+  }
+
+  public static generatorKeyByMessage(message: EventMessage) {
+    return `${message.category}#${message.type}`;
+  }
+}

package/src/bus/operator/index.ts

@@ -0,0 +1,2 @@
+export * from './consumer';
+export * from './producer';

package/src/bus/operator/producer.ts

@@ -0,0 +1,56 @@
+import { instantiate } from '@oinone/kunlun-shared';
+import { selectorEventProducer } from '../spi';
+import { EventCategoryType, EventEngineOptions, EventProducer, EventProducerOptions } from '../typing';
+
+export class ProducerOperator {
+  private static producers: Map<string, EventProducer<unknown>> = new Map<
+    string,
+    EventProducer<unknown, unknown, unknown>
+  >();
+
+  public static getProducer<K = string, EV = unknown, V = EV>(
+    category: EventCategoryType,
+    type: string
+  ): EventProducer<K, EV, V> | undefined {
+    return ProducerOperator.producers.get(ProducerOperator.generatorKey(category, type)) as
+      | EventProducer<K, EV, V>
+      | undefined;
+  }
+
+  public static construct<K = string, EV = unknown, V = EV>(
+    options: EventEngineOptions,
+    producerOptions?: EventProducerOptions<K, EV, V>
+  ): EventProducer<K, EV, V> {
+    const ProducerConstructor = selectorEventProducer<K, EV, V>(options);
+    if (!ProducerConstructor) {
+      throw new Error(`Unsupported producer. category: ${options.category}, type: ${options.type}`);
+    }
+    return instantiate(ProducerConstructor, options.type, producerOptions);
+  }
+
+  public static init<K = string, EV = unknown, V = EV>(producer: EventProducer<K, EV, V>): void {
+    const key = ProducerOperator.generatorKeyByEngine(producer);
+    ProducerOperator.dispose(key);
+    ProducerOperator.producers.set(key, producer);
+    producer.start();
+  }
+
+  public static dispose<K = string, EV = unknown, V = EV>(key: string): EventProducer<K, EV, V> | undefined {
+    const producer = ProducerOperator.producers.get(key);
+    if (producer) {
+      ProducerOperator.producers.delete(key);
+      if (!producer.isDisposed) {
+        producer.dispose();
+      }
+    }
+    return producer as EventProducer<K, EV, V> | undefined;
+  }
+
+  public static generatorKey(category: string, type: string) {
+    return `${category}#${type}`;
+  }
+
+  public static generatorKeyByEngine<K = string, EV = unknown, V = EV>(producer: EventProducer<K, EV, V>) {
+    return `${producer.category}#${producer.type}`;
+  }
+}

package/src/bus/spi/consumer.ts

@@ -0,0 +1,34 @@
+import { SPIOperator, SPIOptions } from '@oinone/kunlun-spi';
+import { EventCategoryType, EventConsumerConfig, EventConsumerConstructor, EventMessage } from '../typing';
+
+const EVENT_BUS_CONSUMER_KEY = Symbol('__event_bus_consumer');
+
+export interface EventBusConsumerOptions extends SPIOptions {
+  category: EventCategoryType | EventCategoryType[];
+  type?: string | string[];
+}
+
+SPIOperator.createStorage({
+  key: EVENT_BUS_CONSUMER_KEY,
+  matchKeys: ['category', 'type']
+});
+
+export function registerEventConsumer<
+  K = string,
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+>(options: EventBusConsumerOptions, constructor: EventConsumerConstructor<K, EV, V, M, C>) {
+  return SPIOperator.register(EVENT_BUS_CONSUMER_KEY, options, constructor);
+}
+
+export function selectorEventConsumer<
+  K = string,
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+>(options: EventBusConsumerOptions): EventConsumerConstructor<K, EV, V, M, C> | undefined {
+  return SPIOperator.selector(EVENT_BUS_CONSUMER_KEY, options);
+}

package/src/bus/spi/index.ts

@@ -0,0 +1,2 @@
+export * from './consumer';
+export * from './producer';

package/src/bus/spi/producer.ts

@@ -0,0 +1,27 @@
+import { SPIOperator, SPIOptions } from '@oinone/kunlun-spi';
+import { EventCategoryType, EventProducerConstructor } from '../typing';
+
+const EVENT_BUS_PRODUCER_KEY = Symbol('__event_bus_producer');
+
+export interface EventBusProducerOptions extends SPIOptions {
+  category: EventCategoryType | EventCategoryType[];
+  type?: string | string[];
+}
+
+SPIOperator.createStorage({
+  key: EVENT_BUS_PRODUCER_KEY,
+  matchKeys: ['category', 'type']
+});
+
+export function registerEventProducer<K = string, EV = unknown, V = EV>(
+  options: EventBusProducerOptions,
+  constructor: EventProducerConstructor<K, EV, V>
+) {
+  return SPIOperator.register(EVENT_BUS_PRODUCER_KEY, options, constructor);
+}
+
+export function selectorEventProducer<K = string, EV = unknown, V = EV>(
+  options: EventBusProducerOptions
+): EventProducerConstructor<K, EV, V> | undefined {
+  return SPIOperator.selector(EVENT_BUS_PRODUCER_KEY, options);
+}

package/src/bus/typing/basic.ts

@@ -0,0 +1,126 @@
+import { EventCategoryType } from './category';
+
+export interface EventEngine<K = string> {
+  key: string;
+
+  category: EventCategoryType;
+
+  type: K;
+
+  isActivated: boolean;
+
+  isDisposed: boolean;
+
+  start(): boolean;
+
+  stop(): boolean;
+
+  dispose(): boolean;
+}
+
+export interface EventProducer<K = string, EV = unknown, V = EV> extends EventEngine<K> {
+  convert(ev: EV): EventMessage<V> | undefined;
+
+  publish(ev: EV): void;
+}
+
+export type EventProducerConstructor<K = string, EV = unknown, V = EV> =
+  | (new (type: string, options?: EventProducerOptions<K, EV, V>) => EventProducer<K, EV, V>)
+  | EventProducer<K, EV, V>;
+
+export interface EventProducerOptions<K = string, EV = unknown, V = EV> {
+  convert?: EventConvertFunction<K, EV, V>;
+  publish?: EventPublishFunction<K, EV, V>;
+}
+
+export type EventConvertFunction<K = string, EV = unknown, V = EV> = (
+  self: EventProducer<K, EV, V>,
+  ev: EV
+) => EventMessage<V> | undefined;
+
+export type EventPublishFunction<K = string, EV = unknown, V = EV> = (self: EventProducer<K, EV, V>, ev: EV) => void;
+
+export interface EventConsumer<
+  K = string,
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+> extends EventEngine<K> {
+  el?: HTMLElement;
+
+  config: C;
+
+  filter(ev: EV, message: M): boolean;
+
+  consumer(message: M): void;
+}
+
+export type EventConsumerConstructor<
+  K = string,
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+> = new (
+  type: string,
+  consumer: EventConsumerFunction<K, EV, V, M, C>,
+  options?: EventConsumerOptions<EV, V, M, C>
+) => EventConsumer<K, EV, V, M, C>;
+
+export interface EventConsumerOptions<
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+> {
+  config?: C;
+  filter?: EventConsumerFilter<EV, V, M>;
+}
+
+export interface EventConsumerConfig {
+  /**
+   * 作用范围
+   */
+  scope?: EventConsumerScope;
+  /**
+   * 指针悬浮时启用
+   */
+  pointerActivated?: boolean;
+  /**
+   * 隐藏时禁用
+   */
+  invisibleDeactivated?: boolean;
+
+  [key: string]: unknown;
+}
+
+export type EventConsumerFilter<EV = unknown, V = EV, M extends EventMessage<V> = EventMessage<V>> = (
+  ev: EV,
+  message: M
+) => boolean;
+
+export type EventConsumerFunction<
+  K = string,
+  EV = unknown,
+  V = EV,
+  M extends EventMessage<V> = EventMessage<V>,
+  C extends EventConsumerConfig = EventConsumerConfig
+> = (self: EventConsumer, message: M) => void;
+
+export interface EventMessage<V = unknown> {
+  category: EventCategoryType;
+  type: string;
+  origin: V;
+}
+
+export type EventEngineOptions = {
+  category: EventCategoryType;
+  type: string | '*';
+};
+
+export enum EventConsumerScope {
+  global = 'global',
+  view = 'view',
+  current = 'current'
+}

package/src/bus/typing/category.ts

@@ -0,0 +1,6 @@
+export enum EventCategory {
+  html = 'html',
+  keyboard = 'keyboard'
+}
+
+export type EventCategoryType = keyof typeof EventCategory | string;

package/src/bus/typing/index.ts

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

package/src/bus/typing/keyboard.ts

@@ -0,0 +1,21 @@
+import { EventConsumerConfig, EventMessage } from './basic';
+
+export interface KeyboardEventMessage extends EventMessage<KeyboardEvent> {
+  code: string;
+  key: string;
+  ctrl: boolean;
+  alt: boolean;
+  shift: boolean;
+}
+
+export type KeyboardKeys = '*' | string | string[];
+
+export type KeyboardType = 'keypress' | 'keyup' | 'keydown';
+
+export const KeyboardTypes: KeyboardType[] = ['keypress', 'keyup', 'keydown'];
+
+export interface HTMLKeyboardEventConsumerConfig extends EventConsumerConfig {
+  ctrl?: boolean;
+  alt?: boolean;
+  shift?: boolean;
+}

package/src/effects/effectbox.ts

@@ -0,0 +1,22 @@
+import { isStr, isFn } from '../helper';
+import { LifeCycle, LifeCycleHeart } from '../lifecycle';
+import { RegistryType, LifeCycleTypes } from '../typing';
+
+function creatEffectHook<V, C>(lifeType: LifeCycleTypes, registryType: RegistryType) {
+  return (type: string, callback?: (ctx: C) => void) => {
+    if (!isStr(type)) {
+      throw new Error(`arg[0] must be string, but now is ${typeof type}`);
+    }
+
+    if (callback) {
+      if (isFn(callback)) {
+        LifeCycleHeart.setType(registryType);
+        LifeCycleHeart.setLifeCycle(lifeType, type, new LifeCycle<C>(callback));
+      } else {
+        throw new Error(`arg[1] must be function`);
+      }
+    }
+  };
+}
+
+export { creatEffectHook };

package/src/effects/fieldEffects.ts

@@ -0,0 +1,99 @@
+import { LifeCycleTypes, RegistryType } from '../typing';
+import { creatEffectHook } from './effectbox';
+
+function createFieldEffect<V = any, C = any>(lifeType: LifeCycleTypes) {
+  return creatEffectHook<V, C>(lifeType, RegistryType.FIELD);
+}
+
+/**
+ * 字段生命周期 字段创建前
+ */
+const onFieldBeforeCreate = createFieldEffect(LifeCycleTypes.ON_FIELD_BEFORE_CREATED);
+
+/**
+ * 字段生命周期 字段已被创建
+ */
+const onFieldCreated = createFieldEffect(LifeCycleTypes.ON_FIELD_CREATED);
+
+/**
+ * 字段生命周期 字段挂载前
+ */
+const onFieldBeforeMount = createFieldEffect(LifeCycleTypes.ON_FIELD_BEFORE_MOUNT);
+
+/**
+ * 字段生命周期 字段已经挂载在页面上
+ */
+const onFieldMounted = createFieldEffect(LifeCycleTypes.ON_FIELD_MOUNTED);
+
+/**
+ * 字段生命周期 字段修改前
+ */
+const onFieldBeforeUpdate = createFieldEffect(LifeCycleTypes.ON_FIELD_BEFORE_UPDATE);
+
+/**
+ * 字段生命周期 字段已被修改
+ */
+const onFieldUpdated = createFieldEffect(LifeCycleTypes.ON_FIELD_UPDATED);
+
+/**
+ * 字段生命周期 字段销毁前
+ */
+const onFieldBeforeUnmount = createFieldEffect(LifeCycleTypes.ON_FIELD_BEFORE_UNMOUNT);
+
+/**
+ * 字段生命周期 字段已被销毁
+ */
+const onFieldUnmounted = createFieldEffect(LifeCycleTypes.ON_FIELD_UNMOUNTED);
+
+/**
+ * 字段生命周期 单字段校验  校验开始
+ */
+const onFieldValidateStart = createFieldEffect(LifeCycleTypes.ON_FIELD_VALIDATE_START);
+
+/**
+ * 字段生命周期 单字段校验  校验成功
+ */
+const onFieldValidateSuccess = createFieldEffect(LifeCycleTypes.ON_FIELD_VALIDATE_SUCCESS);
+
+/**
+ * 字段生命周期 单字段校验  校验失败
+ */
+const onFieldValidateFailed = createFieldEffect(LifeCycleTypes.ON_FIELD_VALIDATE_FAILED);
+
+/**
+ * 字段生命周期 单字段校验  校验结束
+ */
+const onFieldValidateEnd = createFieldEffect(LifeCycleTypes.ON_FIELD_VALIDATE_END);
+
+/**
+ * 字段生命周期 字段获得焦点
+ */
+const onFieldFocus = createFieldEffect(LifeCycleTypes.ON_FIELD_FOCUS);
+
+/**
+ * 字段生命周期 字段的值发生的修改（只有该字段发生了change方法才会触发，否则不触发）
+ */
+const onFieldValueChange = createFieldEffect(LifeCycleTypes.ON_FIELD_CHANGE);
+
+/**
+ * 字段生命周期 字段失去焦点
+ */
+const onFieldBlur = createFieldEffect(LifeCycleTypes.ON_FIELD_BLUR);
+
+export {
+  onFieldBeforeCreate,
+  onFieldCreated,
+  onFieldBeforeMount,
+  onFieldMounted,
+  onFieldBeforeUpdate,
+  onFieldUpdated,
+  onFieldBeforeUnmount,
+  onFieldUnmounted,
+  onFieldValidateStart,
+  onFieldValidateSuccess,
+  onFieldValidateFailed,
+  onFieldValidateEnd,
+  onFieldFocus,
+  onFieldValueChange,
+  onFieldBlur
+};

package/src/effects/index.ts

@@ -0,0 +1,2 @@
+export * from './fieldEffects';
+export * from './viewEffects';

package/src/effects/viewEffects.ts

@@ -0,0 +1,111 @@
+import { LifeCycleTypes, RegistryType } from '../typing';
+import { creatEffectHook } from './effectbox';
+
+function createViewEffect<V = any, C = any>(lifeType: LifeCycleTypes) {
+  return creatEffectHook<V, C>(lifeType, RegistryType.VIEW);
+}
+
+/**
+ * 视图生命周期 视图创建前
+ */
+const onViewBeforeCreated = createViewEffect(LifeCycleTypes.ON_VIEW_BEFORE_CREATED);
+
+/**
+ * 视图生命周期 视图已被创建
+ */
+const onViewCreated = createViewEffect(LifeCycleTypes.ON_VIEW_CREATED);
+
+/**
+ * 视图生命周期 视图挂载前
+ */
+const onViewBeforeMount = createViewEffect(LifeCycleTypes.ON_VIEW_BEFORE_MOUNT);
+
+/**
+ * 视图生命周期 视图已经挂载在页面上
+ */
+const onViewMounted = createViewEffect(LifeCycleTypes.ON_VIEW_MOUNTED);
+
+/**
+ * 视图生命周期 视图修改前
+ */
+const onViewBeforeUpdate = createViewEffect(LifeCycleTypes.ON_VIEW_BEFORE_UPDATE);
+
+/**
+ * 视图生命周期 视图已被修改
+ */
+const onViewUpdated = createViewEffect(LifeCycleTypes.ON_VIEW_UPDATED);
+
+/**
+ * 视图生命周期 视图销毁前
+ */
+const onViewBeforeUnmount = createViewEffect(LifeCycleTypes.ON_VIEW_BEFORE_UNMOUNT);
+
+/**
+ * 视图生命周期 视图已被销毁
+ */
+const onViewUnmounted = createViewEffect(LifeCycleTypes.ON_VIEW_UNMOUNTED);
+
+/**
+ * 视图生命周期 视图数据提交
+ */
+const onViewSubmit = createViewEffect(LifeCycleTypes.ON_VIEW_SUBMIT);
+
+/**
+ * 视图生命周期 视图数据开始提交
+ */
+const onViewSubmitStart = createViewEffect(LifeCycleTypes.ON_VIEW_SUBMIT_START);
+
+/**
+ * 视图生命周期 视图数据提交成功
+ */
+const onViewSubmitSuccess = createViewEffect(LifeCycleTypes.ON_VIEW_SUBMIT_SUCCESS);
+
+/**
+ * 视图生命周期 视图数据提交失败
+ */
+const onViewSubmitFailed = createViewEffect(LifeCycleTypes.ON_VIEW_SUBMIT_FAILED);
+
+/**
+ * 视图生命周期 视图数据提交结束
+ */
+const onViewSubmitEnd = createViewEffect(LifeCycleTypes.ON_VIEW_SUBMIT_END);
+
+/**
+ * 视图生命周期 视图开始校验，只有表单页才会触发
+ */
+const onViewValidateStart = createViewEffect(LifeCycleTypes.ON_VIEW_VALIDATE_START);
+
+/**
+ * 视图生命周期 视图校验成功，只有表单页才会触发
+ */
+const onViewValidateSuccess = createViewEffect(LifeCycleTypes.ON_VIEW_VALIDATE_SUCCESS);
+
+/**
+ * 视图生命周期 视图校验失败，只有表单页才会触发
+ */
+const onViewValidateFailed = createViewEffect(LifeCycleTypes.ON_VIEW_VALIDATE_FAILED);
+
+/**
+ * 视图生命周期 视图校验结束，只有表单页才会触发
+ */
+const onViewValidateEnd = createViewEffect(LifeCycleTypes.ON_VIEW_VALIDATE_END);
+
+export {
+  onViewBeforeCreated,
+  onViewCreated,
+  onViewBeforeMount,
+  onViewMounted,
+  onViewBeforeUpdate,
+  onViewUpdated,
+  onViewBeforeUnmount,
+  onViewUnmounted,
+  onViewSubmit,
+  onViewSubmitStart,
+  onViewSubmitSuccess,
+  onViewSubmitFailed,
+  onViewSubmitEnd,
+  onViewValidateStart,
+  onViewValidateSuccess,
+  onViewValidateFailed,
+  onViewValidateEnd
+};