@ibiz-template/runtime 0.0.1-alpha.9 → 0.0.1-beta.17

package/src/controller/neuron/counter/nerve-counter.ts

@@ -0,0 +1,52 @@
+import { Counter } from '../../utils/counter/counter';
+
+/**
+ * 神经系统计数器
+ *
+ * @author lxm
+ * @date 2022-09-21 18:09:53
+ * @export
+ * @class NerveCounter
+ * @extends {Counter}
+ */
+export class NerveCounter extends Counter {
+  protected reusable: boolean = false;
+
+  /**
+   * 管理的神经元名称集合
+   *
+   * @author lxm
+   * @date 2022-09-21 18:09:27
+   * @type {string[]}
+   */
+  neuronNames: Map<string, boolean> = new Map();
+
+  /**
+   * 登记要管理的神经元
+   *
+   * @author lxm
+   * @date 2022-09-21 18:09:01
+   * @param {string} name
+   */
+  enroll(name: string) {
+    if (!this.neuronNames.has(name)) {
+      this.neuronNames.set(name, false);
+      this.increment();
+    }
+  }
+
+  /**
+   * 确认管理的神经元已经处理完了它所要做的事情
+   *
+   * @author lxm
+   * @date 2022-09-21 18:09:09
+   * @param {string} name
+   */
+  attend(name: string) {
+    // 在名称集合内，且未false时
+    if (this.neuronNames.has(name) && this.neuronNames.get(name) === false) {
+      this.neuronNames.set(name, true);
+      this.decrement();
+    }
+  }
+}

package/src/controller/neuron/index.ts

@@ -0,0 +1,12 @@
+// 导出神经计数器
+export * from './counter/nerve-counter';
+
+// 导出神经元
+export * from './neuron/neuron';
+export * from './neuron/widget';
+export * from './neuron/view';
+
+// 导出神经系统
+export * from './nerve/nerve';
+export * from './nerve/control';
+export * from './nerve/view';

package/src/controller/neuron/nerve/control/app-menu-nerve.ts

@@ -0,0 +1,21 @@
+import { AppMenuNeuron } from '../..';
+import { AppMenuController } from '../../..';
+import { ControlNerve } from './control-nerve';
+
+/**
+ * 编辑表单神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:14
+ * @export
+ * @class AppMenuNerve
+ * @extends {ControlNerve<AppMenuNeuron, AppMenuController>}
+ */
+export class AppMenuNerve extends ControlNerve<
+  AppMenuNeuron,
+  AppMenuController
+> {
+  protected createNeuron(): AppMenuNeuron {
+    return new AppMenuNeuron(this.bindAbility());
+  }
+}

package/src/controller/neuron/nerve/control/control-nerve.ts

@@ -0,0 +1,40 @@
+import { ControlNeuron, Neuron } from '../..';
+import { ControlController } from '../../..';
+import { Nerve } from '../nerve';
+
+/**
+ * 基础部件神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:59
+ * @export
+ * @class ControlNerve
+ * @extends {Nerve<T, C>}
+ * @template T
+ * @template C
+ */
+export class ControlNerve<
+  T extends ControlNeuron = ControlNeuron,
+  C extends ControlController = ControlController,
+> extends Nerve<T, C> {
+  protected createNeuron(): T {
+    return new ControlNeuron(this.bindAbility()) as T;
+  }
+
+  /**
+   * 监听通用神经元事件
+   *
+   * @author lxm
+   * @date 2022-09-19 15:09:14
+   * @param {ControlNeuron} neuron 部件神经元
+   */
+  listenCommonEvent(name: string, neuron: ControlNeuron) {
+    neuron.evt.on('mounted', () => {
+      this.counter.attend(name);
+    });
+  }
+
+  connect(name: string, neuron: Neuron): void {
+    this.listenCommonEvent(name, neuron);
+  }
+}

package/src/controller/neuron/nerve/control/dashboard-nerve.ts

@@ -0,0 +1,21 @@
+import { DashboardNeuron } from '../..';
+import { DashboardController } from '../../..';
+import { ControlNerve } from './control-nerve';
+
+/**
+ * 数据看板神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:14
+ * @export
+ * @class DashboardNerve
+ * @extends {ControlNerve<DashboardNeuron, DashboardController>}
+ */
+export class DashboardNerve<
+  N extends DashboardNeuron = DashboardNeuron,
+  C extends DashboardController = DashboardController,
+> extends ControlNerve<N, C> {
+  protected createNeuron(): N {
+    return new DashboardNeuron(this.bindAbility()) as N;
+  }
+}

package/src/controller/neuron/nerve/control/edit-form-nerve.ts

@@ -0,0 +1,30 @@
+import { EditFormNeuron, FormNerve } from '../..';
+import { EditFormController } from '../../..';
+
+/**
+ * 编辑表单神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:14
+ * @export
+ * @class EditFormNerve
+ * @extends {ControlNerve<EditFormNeuron, EditFormController>}
+ */
+export class EditFormNerve extends FormNerve<
+  EditFormNeuron,
+  EditFormController
+> {
+  protected createNeuron(): EditFormNeuron {
+    return new EditFormNeuron(this.bindAbility());
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      save: this.controller.save.bind(this.controller),
+      remove: this.controller.remove.bind(this.controller),
+      wfStart: this.controller.wfStart.bind(this.controller),
+      wfSubmit: this.controller.wfSubmit.bind(this.controller),
+    };
+  }
+}

package/src/controller/neuron/nerve/control/form-nerve.ts

@@ -0,0 +1,29 @@
+import { FormNeuron } from '../..';
+import { FormController } from '../../..';
+import { ControlNerve } from './control-nerve';
+
+/**
+ * 表单神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:14
+ * @export
+ * @class FormNerve
+ * @extends {ControlNerve<FormNeuron, FormController>}
+ */
+export class FormNerve<
+  N extends FormNeuron = FormNeuron,
+  C extends FormController = FormController,
+> extends ControlNerve<N, C> {
+  protected createNeuron(): N {
+    return new FormNeuron(this.bindAbility()) as N;
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      load: this.controller.load.bind(this.controller),
+      getData: this.controller.getData.bind(this.controller),
+    };
+  }
+}

package/src/controller/neuron/nerve/control/grid-nerve.ts

@@ -0,0 +1,26 @@
+import { GridNeuron } from '../..';
+import { GridController } from '../../../control/grid';
+import { MDControlNerve } from './md-control-nerve';
+
+/**
+ * 表格神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:39
+ * @export
+ * @class GridNerve
+ * @extends {MDControlNerve<GridNeuron, GridController>}
+ */
+export class GridNerve extends MDControlNerve<GridNeuron, GridController> {
+  protected createNeuron(): GridNeuron {
+    return new GridNeuron(this.bindAbility());
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      save: this.controller.save.bind(this.controller),
+      newRow: this.controller.newRow.bind(this.controller),
+    };
+  }
+}

package/src/controller/neuron/nerve/control/index.ts

@@ -0,0 +1,11 @@
+export * from './control-nerve';
+export * from './app-menu-nerve';
+export * from './md-control-nerve';
+export * from './grid-nerve';
+export * from './list-nerve';
+export * from './form-nerve';
+export * from './edit-form-nerve';
+export * from './search-form-nerve';
+export * from './view-panel-nerve';
+export * from './pickup-view-panel-nerve';
+export * from './dashboard-nerve';

package/src/controller/neuron/nerve/control/list-nerve.ts

@@ -0,0 +1,18 @@
+import { ListNeuron } from '../..';
+import { ListController } from '../../../control/list';
+import { MDControlNerve } from './md-control-nerve';
+
+/**
+ * 列表神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:39
+ * @export
+ * @class ListNerve
+ * @extends {MDControlNerve<ListNeuron, ListController>}
+ */
+export class ListNerve extends MDControlNerve<ListNeuron, ListController> {
+  protected createNeuron(): ListNeuron {
+    return new ListNeuron(this.bindAbility());
+  }
+}

package/src/controller/neuron/nerve/control/md-control-nerve.ts

@@ -0,0 +1,35 @@
+import { MDControlNeuron } from '../..';
+import { MDController } from '../../..';
+import { ControlNerve } from './control-nerve';
+
+/**
+ * 多数据部件神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:57
+ * @export
+ * @class MDControlNerve
+ * @extends {ControlNerve<T, C>}
+ * @template T
+ * @template C
+ */
+export class MDControlNerve<
+  T extends MDControlNeuron = MDControlNeuron,
+  C extends MDController = MDController,
+> extends ControlNerve<T, C> {
+  protected createNeuron(): T {
+    return new MDControlNeuron(this.bindAbility()) as T;
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      load: this.controller.load.bind(this.controller),
+      remove: this.controller.remove.bind(this.controller),
+      getData: this.controller.getData.bind(this.controller),
+      selectAll: this.controller.selectAll.bind(this.controller),
+      importData: this.controller.importData.bind(this.controller),
+      exportData: this.controller.exportData.bind(this.controller),
+    };
+  }
+}

package/src/controller/neuron/nerve/control/pickup-view-panel-nerve.ts

@@ -0,0 +1,41 @@
+import { Neuron, PickupGridViewNeuron, PickupViewPanelNeuron } from '../..';
+import { PickupViewPanelController } from '../../..';
+import { ViewPanelNerve } from './view-panel-nerve';
+
+/**
+ * 选择视图面板神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:11
+ * @export
+ * @class PickupViewPanelNerve
+ * @extends {ViewPanelNerve<PickupViewPanelNeuron, PickupViewPanelController>}
+ */
+export class PickupViewPanelNerve extends ViewPanelNerve<
+  PickupViewPanelNeuron,
+  PickupViewPanelController
+> {
+  declare embedView: PickupGridViewNeuron;
+
+  protected createNeuron(): PickupViewPanelNeuron {
+    return new PickupViewPanelNeuron(this.bindAbility());
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      selectAll: this.controller.selectAll.bind(this.controller),
+    };
+  }
+
+  connect(name: string, neuron: Neuron): void {
+    super.connect(name, neuron);
+    // 监听嵌入视图，选择类视图会抛数据选择变更事件
+    if (name === 'embedView') {
+      this.embedView = neuron as PickupGridViewNeuron;
+      this.embedView.evt.on('selectionChange', data => {
+        this.self.evt.asyncEmit('selectionChange', data);
+      });
+    }
+  }
+}

package/src/controller/neuron/nerve/control/search-form-nerve.ts

@@ -0,0 +1,27 @@
+import { FormNerve, SearchFormNeuron } from '../..';
+import { SearchFormController } from '../../..';
+
+/**
+ * 搜索表单神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:14
+ * @export
+ * @class SearchFormNerve
+ * @extends {ControlNerve<SearchFormNeuron, SearchFormController>}
+ */
+export class SearchFormNerve extends FormNerve<
+  SearchFormNeuron,
+  SearchFormController
+> {
+  protected createNeuron(): SearchFormNeuron {
+    return new SearchFormNeuron(this.bindAbility());
+  }
+
+  protected bindAbility() {
+    return {
+      ...super.bindAbility(),
+      getParams: this.controller.getParams.bind(this.controller),
+    };
+  }
+}

package/src/controller/neuron/nerve/control/view-panel-nerve.ts

@@ -0,0 +1,55 @@
+import { MDViewNeuron, Neuron, ViewNeuron, ViewPanelNeuron } from '../..';
+import { ViewPanelController } from '../../..';
+import { ControlNerve } from './control-nerve';
+
+/**
+ * 视图面板神经系统
+ *
+ * @author lxm
+ * @date 2022-09-13 16:09:30
+ * @export
+ * @class ViewPanelNerve
+ * @extends {ControlNerve<T, C>}
+ * @template T
+ * @template C
+ */
+export class ViewPanelNerve<
+  T extends ViewPanelNeuron = ViewPanelNeuron,
+  C extends ViewPanelController = ViewPanelController,
+> extends ControlNerve<T, C> {
+  /**
+   * 嵌入视图的神经元
+   *
+   * @author lxm
+   * @date 2022-09-13 17:09:49
+   * @type {ViewNeuron}
+   */
+  embedView!: ViewNeuron;
+
+  protected createNeuron(): T {
+    return new ViewPanelNeuron(this.bindAbility()) as T;
+  }
+
+  inclusive(name: string): boolean {
+    return name === 'embedView' || super.inclusive(name);
+  }
+
+  connect(name: string, neuron: Neuron): void {
+    super.connect(name, neuron);
+    // 连接嵌入视图神经元,并监听其事件，名称是外面给死的
+    if (name === 'embedView') {
+      this.embedView = neuron as ViewNeuron;
+      (this.embedView as MDViewNeuron).evt.on('viewDataChange', data => {
+        this.self.evt.asyncEmit('viewDataChange', data);
+      });
+      this.embedView.evt.on('destroyed', () => {
+        this.embedView = undefined as never;
+      });
+    }
+  }
+
+  destroy(): void {
+    super.destroy();
+    this.embedView = undefined as never;
+  }
+}

package/src/controller/neuron/nerve/nerve.ts

@@ -0,0 +1,183 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { NerveCounter, Neuron } from '..';
+import { ControlController } from '../../control/control';
+import { IComponentEvent } from '../../interface';
+import { ViewController } from '../../view/view';
+
+export type TypeAbility<T> = T extends Neuron<infer E, infer A> ? A : never;
+export type TypeEvent<T> = T extends Neuron<infer E, infer A> ? E : never;
+export type Controller = ControlController | ViewController;
+/**
+ * 神经，
+ * - 管理自身神经元的创建，销毁，能力绑定
+ * - 管理下级神经元的存储和挂载计数，销毁，判断所有神经元是否都准备完毕
+ *
+ * @author lxm
+ * @date 2022-09-13 11:09:08
+ * @export
+ * @class Nerve
+ */
+export abstract class Nerve<
+  T extends Neuron<IComponentEvent> = Neuron<IComponentEvent>,
+  C extends Controller = Controller,
+> {
+  /**
+   * 自己本身的神经元
+   *
+   * @author lxm
+   * @date 2022-09-13 16:09:44
+   * @type {T}
+   */
+  self: T;
+
+  /**
+   * 神经元状态计数器
+   *
+   * @author lxm
+   * @date 2022-09-13 14:09:20
+   * @type {number}
+   */
+  counter = new NerveCounter(this.counterCallBack.bind(this));
+
+  /**
+   * 部件或者视图控制器
+   *
+   * @author lxm
+   * @date 2022-09-13 16:09:33
+   * @protected
+   * @type {C}
+   */
+  protected controller: C;
+
+  /**
+   * 在控制器拥有emit能力后就可以创建神经系统
+   * @author lxm
+   * @date 2022-09-13 18:09:42
+   * @param {C} controller
+   */
+  constructor(controller: C) {
+    this.controller = controller;
+    this.self = this.createNeuron();
+    this.counter.enroll('self');
+  }
+
+  /**
+   * 计数器回调，当计数器完成计数归零时触发
+   *
+   * @author lxm
+   * @date 2022-09-21 18:09:25
+   * @protected
+   */
+  protected counterCallBack(): void {
+    this.self.evt.emit('mounted');
+  }
+
+  /**
+   * !子类必须覆盖，返回自身的神经元实例
+   * 用bindAbility绑定自身的能力
+   *
+   * @author lxm
+   * @date 2022-09-13 16:09:02
+   * @protected
+   * @returns {*}  {T}
+   */
+  protected abstract createNeuron(): T;
+
+  /**
+   * 子类实现，绑定自身的神经元能力
+   * 可沿用基类的绑定
+   *
+   * @author lxm
+   * @date 2022-09-13 16:09:04
+   * @protected
+   * @returns {*}
+   */
+  protected bindAbility(): IObject {
+    return {};
+  }
+
+  /**
+   * 是否处理对应名称的神经元
+   * 通过重写来管理子神经元的过滤
+   *
+   * @author lxm
+   * @date 2022-09-21 19:09:21
+   * @param {string} _name 神经元的名称
+   * @returns {*}  {boolean}
+   */
+  inclusive(_name: string): boolean {
+    return false;
+  }
+
+  /**
+   * 连接下级神经元回调。做如下处理
+   * - 绑定需要的神经元到神经系统上
+   * - 连接时监听对应神经元事件
+   *
+   * @author lxm
+   * @date 2022-09-13 14:09:30
+   * @param {string} _name
+   * @param {Neuron} _neuron
+   */
+  protected connect(_name: string, _neuron: Neuron): void {
+    // 有下级神经元的添加处理
+  }
+
+  /**
+   * 绑定子组件neuronInit事件时使用
+   * 用于确定具体有哪些子组件需要被等待
+   *
+   * @author lxm
+   * @date 2022-09-21 17:09:10
+   * @param {string} name
+   * @returns {*}
+   */
+  onNeuronInit(name: string): (neuron: Neuron) => void {
+    // 不处理的返回空函数，不做任何处理
+    if (!this.inclusive(name)) {
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      return (neuron: Neuron) => {};
+    }
+    // 计数器登记要用到的神经元
+    this.counter.enroll(name);
+    return (neuron: Neuron) => {
+      this.connect(name, neuron);
+    };
+  }
+
+  /**
+   * 抛出自身神经元的created事件
+   * 即controller的isComplete为true时
+   *
+   * @author lxm
+   * @date 2022-09-21 17:09:19
+   */
+  created(): void {
+    this.self.evt.emit('created');
+  }
+
+  /**
+   * 抛出自身神经元的mounted事件(如果没有下级的)
+   * nerve相关mounted时机的逻辑处理
+   *
+   * @author lxm
+   * @date 2022-09-21 17:09:19
+   */
+  mounted(): void {
+    this.counter.attend('self');
+  }
+
+  /**
+   * 抛出自身神经元的destroyed事件
+   * nerve相关destroyed时机的逻辑处理
+   *
+   * @author lxm
+   * @date 2022-09-13 16:09:19
+   */
+  destroy(): void {
+    this.self.evt.emit('destroyed');
+    this.self.destroy();
+    this.controller = undefined as never;
+    this.self = undefined as never;
+  }
+}

package/src/controller/neuron/nerve/view/app-portal-view-nerve.ts

@@ -0,0 +1,38 @@
+import { ViewNerve, AppPortalViewNeuron, DashboardNeuron, Neuron } from '../..';
+import { AppPortalViewController } from '../../..';
+
+/**
+ * 应用看板视图神经系统
+ *
+ * @author lxm
+ * @date 2022-10-14 14:10:48
+ * @export
+ * @class AppPortalViewNerve
+ * @extends {ViewNerve<AppPortalViewNeuron, AppPortalViewController>}
+ */
+export class AppPortalViewNerve extends ViewNerve<
+  AppPortalViewNeuron,
+  AppPortalViewController
+> {
+  dashboard!: DashboardNeuron;
+
+  protected createNeuron(): AppPortalViewNeuron {
+    return new AppPortalViewNeuron(this.bindAbility());
+  }
+
+  inclusive(name: string): boolean {
+    return name === 'dashboard' || super.inclusive(name);
+  }
+
+  connect(name: string, neuron: Neuron): void {
+    super.connect(name, neuron);
+    if (name === 'dashboard') {
+      this.dashboard = neuron as DashboardNeuron;
+    }
+  }
+
+  destroy(): void {
+    super.destroy();
+    this.dashboard = undefined as never;
+  }
+}