@oinone/kunlun-event 6.2.0

package/dist/types/src/lifecycle/heart.d.ts

@@ -0,0 +1,75 @@
+import { LifeCycle } from './lifecycle';
+import { LifeCycleTypes, RegistryType } from '../typing';
+/**
+ * HeartLifeCycles = [{
+ *  registryType: Field,
+ *  type: onFieldChange,
+ *  pattern: {
+ *    identifier: displayName
+ *    lifes: [LifeCycle]
+ *  }
+ * }]
+ */
+declare type HeartLifeCycles = {
+    type: LifeCycleTypes;
+    registryType: RegistryType;
+    pattern: {
+        identifier: string;
+        lifes: LifeCycle[];
+    }[];
+}[];
+/**
+ * 操作生命周期的api
+ */
+declare class LifeCycleHeart {
+    private static lifeCycles;
+    private static heartType;
+    static initialize(lifeCycles: HeartLifeCycles): void;
+    private static getLifeCycleIndex;
+    static getLifeCycle(): HeartLifeCycles;
+    static getLifeCycleByType(type: LifeCycleTypes): {
+        type: LifeCycleTypes;
+        registryType: RegistryType;
+        pattern: {
+            identifier: string;
+            lifes: LifeCycle<any>[];
+        }[];
+    } | null;
+    /**
+     * 设置生命周期的注册类型,
+     *
+     * @param {registryType} RegistryType 类型
+     */
+    static setType(registryType: RegistryType): void;
+    /**
+     * 设置生命周期
+     * 调用该函数之前要先调用 `setType` 设置注册类型
+     *
+     * @param {type} LifeCycleTypes 生命周期的类型
+     * @param {identifier} string 唯一标识符
+     * @param {lifeCycle} LifeCycle 生命周期的实例
+     *
+     */
+    static setLifeCycle(type: LifeCycleTypes, identifier: string, lifeCycle: LifeCycle): false | undefined;
+    /**
+     * 触发生命周期的回调函数
+     *
+     * @param {type} LifeCycleTypes 生命周期的类型
+     * @param {identifier} string 唯一标识符
+     * @param {ctx} Context 当前「视图/字段/Action」的上下文
+     */
+    static publish<C = any>(type: LifeCycleTypes, identifier: string, ctx: C): false | undefined;
+    /**
+     * @deprecated 销毁生命周期
+     *
+     * @param {identifier} string 唯一标识符
+     */
+    static disposeLifeCycle(identifier: string): void;
+    /**
+     * 销毁生命周期
+     *
+     * @param {identifier} string 唯一标识符
+     */
+    static dispose(identifier: string): void;
+}
+export { LifeCycleHeart };

package/dist/types/src/lifecycle/index.d.ts

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

package/dist/types/src/lifecycle/lifecycle.d.ts

@@ -0,0 +1,7 @@
+declare class LifeCycle<Context = any> {
+    private listener;
+    constructor(callback?: (ctx: Context) => void);
+    private buildListener;
+    notify(ctx: Context): void;
+}
+export { LifeCycle };

package/dist/types/src/typing/index.d.ts

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

package/dist/types/src/typing/lifecycle.d.ts

@@ -0,0 +1,92 @@
+export declare enum RegistryType {
+    FIELD = "Field",
+    VIEW = "View",
+    ACTION = "Action"
+}
+export declare 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 declare enum ViewEventNames {
+    viewBeforeCreated = "onViewBeforeCreated",
+    viewCreated = "onViewCreated",
+    viewBeforeMount = "onViewBeforeMount",
+    viewMounted = "onViewMounted",
+    viewBeforeUpdate = "onViewBeforeUpdate",
+    viewUpdated = "onViewUpdated",
+    viewActivated = "onViewActivated",
+    viewBeforeUnmount = "onViewBeforeUnmount",
+    viewUnmounted = "onViewUnmounted",
+    viewSubmit = "onViewSubmit",
+    viewSubmitStart = "onViewSubmitStart",
+    viewSubmitEnd = "onViewSubmitEnd",
+    viewSubmitSuccess = "onViewSubmitSuccess",
+    viewSubmitFailed = "onViewSubmitFailed",
+    viewValidateStart = "onViewValidateStart",
+    viewValidateSuccess = "onViewValidateSuccess",
+    viewValidateFailed = "onViewValidateFailed",
+    viewValidateEnd = "onViewValidateEnd"
+}
+export declare type ViewEventName = keyof typeof ViewEventNames;
+/**
+ * Field internal event
+ */
+export declare enum FieldEventNames {
+    beforeCreated = "onFieldBeforeCreated",
+    created = "onFieldCreated",
+    beforeMount = "onFieldBeforeMount",
+    mount = "onFieldMounted",
+    beforeUpdate = "onFieldBeforeUpdate",
+    updated = "onViewUpdated",
+    beforeUnmount = "onFieldBeforeUnmount",
+    unmounted = "onFieldUnmounted",
+    focus = "onFieldFocus",
+    change = "onFieldChange",
+    blur = "onFieldBlur",
+    validateStart = "onFieldValidateStart",
+    validateSuccess = "onFieldValidateSuccess",
+    validateFailed = "onFieldValidateFailed",
+    validateEnd = "onFieldValidateEnd"
+}
+export declare type FieldEventName = keyof typeof FieldEventNames;

package/index.ts

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

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@oinone/kunlun-event",
+  "version": "6.2.0",
+  "main": "index.ts",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "rollup -c",
+    "dist": "npm run prepublishOnly",
+    "index": "npm run postpublish",
+    "x-prepublishOnly": "node ../../scripts/prepublish-only.js",
+    "x-postpublish": "node ../../scripts/postpublish.js"
+  },
+  "devDependencies": {
+    "@oinone/kunlun-environment": "6.2.0",
+    "@oinone/kunlun-shared": "6.2.0",
+    "@oinone/kunlun-spi": "6.2.0"
+  },
+  "gitHead": "b65bbf1d649da1017810c5608473d5daa1a41f94"
+}

package/rollup.config.js

@@ -0,0 +1,4 @@
+import pkg from './package.json';
+import rollupConfig from '../../scripts/build.config.js';
+
+export default rollupConfig(pkg.name, ['@oinone/kunlun-shared', '@oinone/kunlun-spi', '@oinone/kunlun-environment']);

package/src/bus/abstract/AbstractEventConsumer.ts

@@ -0,0 +1,79 @@
+import { ConsumerOperator } from '../operator';
+import {
+  EventCategoryType,
+  EventConsumer,
+  EventConsumerConfig,
+  EventConsumerFilter,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventMessage
+} from '../typing';
+import { AbstractEventEngine } from './AbstractEventEngine';
+
+let counter = 0;
+
+export abstract class AbstractEventConsumer<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >
+  extends AbstractEventEngine<K>
+  implements EventConsumer<K, EV, V, M, C>
+{
+  public el: HTMLElement | undefined;
+
+  private readonly _config: C;
+
+  private readonly _rawFilter: EventConsumerFilter<EV, V, M>;
+
+  private readonly _rawConsumer: EventConsumerFunction<K, EV, V, M, C>;
+
+  protected constructor(
+    category: EventCategoryType,
+    type: K,
+    consumer: EventConsumerFunction<K, EV, V, M, C>,
+    options?: EventConsumerOptions<EV, V, M, C>
+  ) {
+    super(category, type);
+    this._config = options?.config || ({} as C);
+    this._rawFilter = options?.filter || this.$$filter.bind(this);
+    this._rawConsumer = consumer;
+  }
+
+  public get config(): C {
+    return this._config;
+  }
+
+  protected get rawFilter(): EventConsumerFilter<EV, V, M> {
+    return this._rawFilter;
+  }
+
+  protected get rawConsumer(): EventConsumerFunction<K, EV, V, M, C> {
+    return this._rawConsumer;
+  }
+
+  public filter(ev: EV, message: M): boolean {
+    if (this.isActivated) {
+      return this.rawFilter(ev, message);
+    }
+    return false;
+  }
+
+  protected $$filter(ev: EV, message: M) {
+    return true;
+  }
+
+  public consumer(message: M): void {
+    return this.rawConsumer(this as unknown as EventConsumer, message);
+  }
+
+  protected generatorKey(): string {
+    return `event_consumer_${counter++}`;
+  }
+
+  protected $$dispose(): void {
+    ConsumerOperator.dispose(this);
+  }
+}

package/src/bus/abstract/AbstractEventEngine.ts

@@ -0,0 +1,79 @@
+import { EventCategoryType, EventEngine } from '../typing';
+
+export abstract class AbstractEventEngine<K = string> implements EventEngine<K> {
+  private readonly _key: string;
+
+  private readonly _category: EventCategoryType;
+
+  private readonly _type: K;
+
+  private _isActivated: boolean;
+
+  private _isDisposed: boolean;
+
+  protected constructor(category: EventCategoryType, type: K) {
+    this._key = this.generatorKey();
+    this._category = category;
+    this._type = type;
+    this._isActivated = false;
+    this._isDisposed = false;
+  }
+
+  public get key(): string {
+    return this._key;
+  }
+
+  public get category(): EventCategoryType {
+    return this._category;
+  }
+
+  public get type(): K {
+    return this._type;
+  }
+
+  public get isActivated(): boolean {
+    return this._isActivated;
+  }
+
+  public get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  public start(): boolean {
+    if (this.isActivated) {
+      return false;
+    }
+    this._isActivated = true;
+    this.$$start();
+    return true;
+  }
+
+  protected $$start(): void {}
+
+  public stop(): boolean {
+    if (this.isActivated) {
+      this._isActivated = false;
+      this.$$stop();
+      return true;
+    }
+    return false;
+  }
+
+  protected $$stop(): void {}
+
+  public dispose(): boolean {
+    if (this.isDisposed) {
+      return false;
+    }
+    if (this.isActivated) {
+      this.stop();
+    }
+    this._isDisposed = true;
+    this.$$dispose();
+    return true;
+  }
+
+  protected $$dispose(): void {}
+
+  protected abstract generatorKey(): string;
+}

package/src/bus/abstract/AbstractEventProducer.ts

@@ -0,0 +1,64 @@
+import { ConsumerOperator, ProducerOperator } from '../operator';
+import {
+  EventCategoryType,
+  EventConvertFunction,
+  EventMessage,
+  EventProducer,
+  EventProducerOptions,
+  EventPublishFunction
+} from '../typing';
+import { AbstractEventEngine } from './AbstractEventEngine';
+
+let counter = 0;
+
+export abstract class AbstractEventProducer<K = string, EV = unknown, V = EV>
+  extends AbstractEventEngine<K>
+  implements EventProducer<K, EV, V>
+{
+  private readonly _rawConvert: EventConvertFunction<K, EV, V>;
+
+  private readonly _rawPublish: EventPublishFunction<K, EV, V>;
+
+  protected constructor(category: EventCategoryType, type: K, options?: EventProducerOptions<K, EV, V>) {
+    super(category, type);
+    this._rawConvert = options?.convert || this.$$convert;
+    this._rawPublish = options?.publish || this.$$publish;
+  }
+
+  public get rawConvert(): EventConvertFunction<K, EV, V> {
+    return this._rawConvert;
+  }
+
+  public get rawPublish(): EventPublishFunction<K, EV, V> {
+    return this._rawPublish;
+  }
+
+  public convert(ev: EV): EventMessage<V> | undefined {
+    return this.rawConvert(this, ev);
+  }
+
+  protected abstract $$convert(self: EventProducer<K, EV, V>, ev: EV): EventMessage<V> | undefined;
+
+  public publish(ev: EV): void {
+    this.rawPublish(this, ev);
+  }
+
+  protected $$publish(self: EventProducer<K, EV, V>, ev: EV): void {
+    const message = this.convert(ev);
+    if (!message) {
+      return;
+    }
+    const consumers = ConsumerOperator.getConsumers(message);
+    if (consumers && consumers.length) {
+      consumers.filter((v) => v.filter(ev, message)).map(async (v) => v.consumer(message));
+    }
+  }
+
+  protected generatorKey(): string {
+    return `event_producer_${counter++}`;
+  }
+
+  protected $$dispose(): void {
+    ProducerOperator.dispose(ProducerOperator.generatorKeyByEngine(this));
+  }
+}

package/src/bus/abstract/index.ts

@@ -0,0 +1,2 @@
+export * from './AbstractEventProducer';
+export * from './AbstractEventConsumer';

package/src/bus/bus/basic.ts

@@ -0,0 +1,124 @@
+import { ConsumerOperator, ProducerOperator } from '../operator';
+import {
+  EventConsumer,
+  EventConsumerConfig,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventEngineOptions,
+  EventMessage,
+  EventProducer,
+  EventProducerOptions
+} from '../typing';
+
+export class Basic {
+  private static consumerMap: Map<Function, EventConsumer<unknown, unknown, unknown>> = new Map<
+    EventConsumerFunction,
+    EventConsumer
+  >();
+
+  public static init<K = string, EV = unknown, V = EV>(
+    options: EventEngineOptions,
+    producerOptions?: EventProducerOptions<K, EV, V>
+  ): EventProducer<K, EV, V> {
+    const { category, type } = options;
+    let producer = ProducerOperator.getProducer<K, EV, V>(category, type);
+    if (!producer) {
+      producer = ProducerOperator.construct<K, EV, V>(
+        {
+          category,
+          type
+        },
+        producerOptions
+      );
+      ProducerOperator.init(producer);
+    }
+    return producer;
+  }
+
+  public static startProducer(options: EventEngineOptions): boolean {
+    const { category, type } = options;
+    const producer = ProducerOperator.getProducer(category, type);
+    if (producer) {
+      return producer.start();
+    }
+    return false;
+  }
+
+  public static stopProducer(options: EventEngineOptions): boolean {
+    const { category, type } = options;
+    const producer = ProducerOperator.getProducer(category, type);
+    if (producer) {
+      return producer.stop();
+    }
+    return false;
+  }
+
+  public static publish<K = string, EV = unknown, V = EV>(options: EventEngineOptions, ev: EV): void {
+    const { category, type } = options;
+    const producer = ProducerOperator.getProducer<K, EV, V>(category, type);
+    if (!producer) {
+      throw new Error('Invalid producer. please initialize the producer before publish.');
+    }
+    producer.publish(ev);
+  }
+
+  public static subscribe<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(
+    options: EventEngineOptions,
+    consumerFn: EventConsumerFunction<K, EV, V, M, C>,
+    consumerOptions?: EventConsumerOptions<EV, V, M, C>
+  ): EventConsumer<K, EV, V, M, C> {
+    const consumer = ConsumerOperator.construct<K, EV, V, M, C>(options, consumerFn, consumerOptions);
+    ConsumerOperator.init(consumer);
+    Basic.consumerMap.set(consumerFn, consumer);
+    return consumer;
+  }
+
+  public static unsubscribe<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(consumerFn: EventConsumerFunction<K, EV, V, M, C>): EventConsumer<K, EV, V> | undefined {
+    const consumer = Basic.consumerMap.get(consumerFn);
+    if (consumer) {
+      Basic.consumerMap.delete(consumerFn);
+      ConsumerOperator.dispose(consumer);
+    }
+    return consumer as EventConsumer<K, EV, V> | undefined;
+  }
+
+  public static startConsumer<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(consumerFn: EventConsumerFunction<K, EV, V, M, C>): boolean {
+    const consumer = Basic.consumerMap.get(consumerFn);
+    if (consumer) {
+      return consumer.start();
+    }
+    return false;
+  }
+
+  public static stopConsumer<
+    K = string,
+    EV = unknown,
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(consumerFn: EventConsumerFunction<K, EV, V, M, C>): boolean {
+    const consumer = Basic.consumerMap.get(consumerFn);
+    if (consumer) {
+      return consumer.stop();
+    }
+    return false;
+  }
+}

package/src/bus/bus/html-event.ts

@@ -0,0 +1,43 @@
+import { ProducerOperator } from '../operator';
+import {
+  EventCategory,
+  EventConsumer,
+  EventConsumerConfig,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventMessage,
+  EventProducer
+} from '../typing';
+import { Basic } from './basic';
+
+export class HTMLEvent {
+  public static init<K extends keyof HTMLElementEventMap, EV = HTMLElementEventMap[K]>(
+    type: K | '*'
+  ): EventProducer<K, EV> {
+    return Basic.init({ category: EventCategory.html, type });
+  }
+
+  public static dispose<K extends keyof HTMLElementEventMap>(
+    type: K | '*'
+  ): EventProducer<K, HTMLElementEventMap[K]> | undefined {
+    return ProducerOperator.dispose(`${EventCategory.html}#${type}`);
+  }
+
+  public static subscribe<
+    K extends keyof HTMLElementEventMap,
+    EV = HTMLElementEventMap[K],
+    V = EV,
+    M extends EventMessage<V> = EventMessage<V>,
+    C extends EventConsumerConfig = EventConsumerConfig
+  >(
+    type: K | '*',
+    consumerFn: EventConsumerFunction<K, EV, V, M, C>,
+    consumerOptions?: EventConsumerOptions<EV, V, M, C>,
+    autoInitProducer = true
+  ): EventConsumer<K, EV, V, M, C> {
+    if (autoInitProducer) {
+      HTMLEvent.init(type);
+    }
+    return Basic.subscribe({ category: EventCategory.html, type }, consumerFn, consumerOptions);
+  }
+}

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

@@ -0,0 +1,46 @@
+import { ProducerOperator } from '../operator';
+import {
+  EventCategory,
+  EventConsumer,
+  EventConsumerFunction,
+  EventConsumerOptions,
+  EventProducer,
+  HTMLKeyboardEventConsumerConfig,
+  KeyboardEventMessage
+} from '../typing';
+import { Basic } from './basic';
+
+const PRODUCER_TYPE = 'global';
+
+export class HTMLKeyboardEvent {
+  public static init(): EventProducer {
+    return Basic.init({ category: EventCategory.keyboard, type: PRODUCER_TYPE });
+  }
+
+  public static dispose(): EventProducer | undefined {
+    return ProducerOperator.dispose(`${EventCategory.keyboard}#${PRODUCER_TYPE}`);
+  }
+
+  public static subscribe(
+    type: string | '*',
+    consumerFn: EventConsumerFunction<
+      string,
+      KeyboardEvent,
+      KeyboardEvent,
+      KeyboardEventMessage,
+      HTMLKeyboardEventConsumerConfig
+    >,
+    consumerOptions?: EventConsumerOptions<
+      KeyboardEvent,
+      KeyboardEvent,
+      KeyboardEventMessage,
+      HTMLKeyboardEventConsumerConfig
+    >,
+    autoInitProducer = true
+  ): EventConsumer<string, KeyboardEvent, KeyboardEvent, KeyboardEventMessage, HTMLKeyboardEventConsumerConfig> {
+    if (autoInitProducer) {
+      HTMLKeyboardEvent.init();
+    }
+    return Basic.subscribe({ category: EventCategory.keyboard, type }, consumerFn, consumerOptions);
+  }
+}