@ibiz-template/core 0.7.41-alpha.101 → 0.7.41-alpha.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ibiz-template/core",
-  "version": "0.7.41-alpha.101",
+  "version": "0.7.41-alpha.106",
   "description": "运行时核心库",
   "type": "module",
   "main": "out/index.js",
@@ -9,6 +9,7 @@
   "files": [
     "dist",
     "out",
+    "src",
     "README.md"
   ],
   "scripts": {
@@ -50,5 +51,5 @@
     "qx-util": "^0.4.8",
     "ramda": "^0.29.0"
   },
-  "gitHead": "f9d085280db4778ad952333525a03889fc37e2ab"
+  "gitHead": "1b3ee8122207b3561d208ba0a491543e409b0b50"
 }

package/src/command/command-register.ts

@@ -0,0 +1,121 @@
+import {
+  ICommand,
+  ICommandHandler,
+  ICommandOption,
+  ICommandRegistry,
+  ICommandsMap,
+  IDisposable,
+} from '../interface';
+import { LinkedList, toDisposable } from './utils';
+
+/**
+ * @description 指令注册中心
+ * @export
+ * @class CommandsRegistry
+ * @implements {ICommandRegistry}
+ */
+export class CommandsRegistry implements ICommandRegistry {
+  /**
+   * @description 已经注册的所有指令
+   * @private
+   * @memberof CommandsRegistry
+   */
+  private readonly commands = new Map<string, LinkedList<ICommand>>();
+
+  /**
+   * @description 注册指令
+   * @param {(string | ICommand)} idOrCommand 指令id或者指令对象
+   * @param {ICommandHandler} [handler] 指令处理器
+   * @param {ICommandOption} [opts] 指令配置参数
+   * @returns {*}  {IDisposable} 返回一个可销毁对象，用于取消注册该指令
+   * @memberof CommandsRegistry
+   */
+  registerCommand(
+    idOrCommand: string | ICommand,
+    handler?: ICommandHandler,
+    opts?: ICommandOption,
+  ): IDisposable {
+    if (!idOrCommand) {
+      throw new Error(`invalid command`);
+    }
+
+    if (typeof idOrCommand === 'string') {
+      if (!handler) {
+        throw new Error(`invalid command`);
+      }
+      return this.registerCommand({ id: idOrCommand, handler, opts });
+    }
+
+    const { id } = idOrCommand;
+
+    let commands = this.commands.get(id);
+    if (!commands) {
+      commands = new LinkedList<ICommand>();
+      this.commands.set(id, commands);
+    }
+
+    const removeFn = commands.unshift(idOrCommand);
+
+    const ret = toDisposable(() => {
+      removeFn();
+      const command = this.commands.get(id);
+      if (command?.isEmpty()) {
+        this.commands.delete(id);
+      }
+    });
+
+    return ret;
+  }
+
+  /**
+   * @description 指令是否已经注册
+   * @param {string} id
+   * @returns {*}  {boolean}
+   * @memberof CommandsRegistry
+   */
+  hasCommand(id: string): boolean {
+    return this.commands.has(id);
+  }
+
+  /**
+   * @description 查找指令
+   * @param {string} id
+   * @returns {*}  {(ICommand | undefined)}
+   * @memberof CommandsRegistry
+   */
+  getCommand(id: string): ICommand | undefined {
+    const list = this.commands.get(id);
+    if (!list || list.isEmpty()) {
+      return undefined;
+    }
+    return list[Symbol.iterator]().next().value;
+  }
+
+  /**
+   * @description 获取所有指令
+   * @returns {*}  {ICommandsMap}
+   * @memberof CommandsRegistry
+   */
+  getCommands(): ICommandsMap {
+    const result = new Map<string, ICommand>();
+    const keys = this.commands.keys();
+    for (const key of keys) {
+      const command = this.getCommand(key);
+      if (command) {
+        result.set(key, command);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @description 获取指令配置参数
+   * @param {string} id
+   * @returns {*}  {(ICommandOption | undefined)}
+   * @memberof CommandsRegistry
+   */
+  getCommandOpt(id: string): ICommandOption | undefined {
+    const cmd = this.getCommand(id);
+    return cmd?.opts;
+  }
+}

package/src/command/command.ts

@@ -0,0 +1,78 @@
+import {
+  ICommandController,
+  ICommandHandler,
+  ICommandOption,
+  IDisposable,
+} from '../interface/command';
+import { CommandsRegistry } from './command-register';
+
+/**
+ * @description 指令控制器
+ * @export
+ * @class CommandController
+ */
+export class CommandController implements ICommandController {
+  /**
+   * @description 指令注册器
+   * @private
+   * @memberof CommandController
+   */
+  private commandRegister = new CommandsRegistry();
+
+  /**
+   * @description 注册指令
+   * @param {string} id 指令id
+   * @param {ICommandHandler} handler 指令处理回调
+   * @param {ICommandOption} [opts] 指令参数
+   * @returns {*}  {IDisposable} 指令释放对象
+   * @memberof CommandController
+   */
+  register(
+    id: string,
+    handler: ICommandHandler,
+    opts?: ICommandOption,
+  ): IDisposable {
+    return this.commandRegister.registerCommand(id, handler, opts);
+  }
+
+  /**
+   * @description 执行指令
+   * @template T
+   * @param {string} id 指令id
+   * @param {...unknown[]} args 指令参数
+   * @returns {*}  {Promise<T>} 指令返回值
+   * @memberof CommandController
+   */
+  async execute<T = undefined>(id: string, ...args: unknown[]): Promise<T> {
+    const command = this.commandRegister.getCommand(id);
+    if (command) {
+      return command.handler(...args) as T | Promise<T>;
+    }
+    throw new Error(ibiz.i18n.t('core.command.unregisteredCommand', { id }));
+  }
+
+  /**
+   * @description 判断指令是否存在，没有则直接抛出异常
+   * @param {string} id 指令id
+   * @param {boolean} [err] 是否抛出异常
+   * @returns {*}  {boolean} 是否存在
+   * @memberof CommandController
+   */
+  hasCommand(id: string, err?: boolean): boolean {
+    const bol = !!this.commandRegister.hasCommand(id);
+    if (err === true && bol === true) {
+      throw new Error(`未注册指令: ${id}，请先注册指令`);
+    }
+    return bol;
+  }
+
+  /**
+   * @description 获取指令参数
+   * @param {string} id 指令id
+   * @returns {*}  {(ICommandOption | undefined)} 指令参数
+   * @memberof CommandController
+   */
+  getCommandOpts(id: string): ICommandOption | undefined {
+    return this.commandRegister.getCommandOpt(id);
+  }
+}

package/src/command/index.ts

@@ -0,0 +1,8 @@
+import { CommandController } from './command';
+
+export * from '../interface/command';
+export * from './utils';
+export { CommandsRegistry } from './command-register';
+export { CommandController } from './command';
+// 命令控制器
+export const commands = new CommandController();

package/src/command/utils/index.ts

@@ -0,0 +1,2 @@
+export { LinkedList } from './linked-list';
+export { toDisposable, debounce, throttle } from './util';

package/src/command/utils/linked-list.ts

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable max-classes-per-file */
+class Node<E> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static readonly Undefined = new Node<any>(undefined);
+
+  element: E;
+
+  next: Node<E>;
+
+  prev: Node<E>;
+
+  constructor(element: E) {
+    this.element = element;
+    this.next = Node.Undefined;
+    this.prev = Node.Undefined;
+  }
+}
+
+export class LinkedList<E> {
+  private _first: Node<E> = Node.Undefined;
+
+  private _last: Node<E> = Node.Undefined;
+
+  private _size: number = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  isEmpty(): boolean {
+    return this._first === Node.Undefined;
+  }
+
+  clear(): void {
+    let node = this._first;
+    while (node !== Node.Undefined) {
+      const { next } = node;
+      node.prev = Node.Undefined;
+      node.next = Node.Undefined;
+      node = next;
+    }
+
+    this._first = Node.Undefined;
+    this._last = Node.Undefined;
+    this._size = 0;
+  }
+
+  unshift(element: E): () => void {
+    return this._insert(element, false);
+  }
+
+  push(element: E): () => void {
+    return this._insert(element, true);
+  }
+
+  private _insert(element: E, atTheEnd: boolean): () => void {
+    const newNode = new Node(element);
+    if (this._first === Node.Undefined) {
+      this._first = newNode;
+      this._last = newNode;
+    } else if (atTheEnd) {
+      // push
+      const oldLast = this._last!;
+      this._last = newNode;
+      newNode.prev = oldLast;
+      oldLast.next = newNode;
+    } else {
+      // unshift
+      const oldFirst = this._first;
+      this._first = newNode;
+      newNode.next = oldFirst;
+      oldFirst.prev = newNode;
+    }
+    this._size += 1;
+
+    let didRemove = false;
+    return () => {
+      if (!didRemove) {
+        didRemove = true;
+        this._remove(newNode);
+      }
+    };
+  }
+
+  shift(): E | undefined {
+    if (this._first === Node.Undefined) {
+      return undefined;
+    }
+    const res = this._first.element;
+    this._remove(this._first);
+    return res;
+  }
+
+  pop(): E | undefined {
+    if (this._last === Node.Undefined) {
+      return undefined;
+    }
+    const res = this._last.element;
+    this._remove(this._last);
+    return res;
+  }
+
+  private _remove(node: Node<E>): void {
+    if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
+      // middle
+      const anchor = node.prev;
+      anchor.next = node.next;
+      node.next.prev = anchor;
+    } else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
+      // only node
+      this._first = Node.Undefined;
+      this._last = Node.Undefined;
+    } else if (node.next === Node.Undefined) {
+      // last
+      this._last = this._last!.prev!;
+      this._last.next = Node.Undefined;
+    } else if (node.prev === Node.Undefined) {
+      // first
+      this._first = this._first!.next!;
+      this._first.prev = Node.Undefined;
+    }
+
+    // done
+    this._size -= 1;
+  }
+
+  *[Symbol.iterator](): Iterator<E> {
+    let node = this._first;
+    while (node !== Node.Undefined) {
+      yield node.element;
+      node = node.next;
+    }
+  }
+}

package/src/command/utils/util.ts

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable func-names */
+/* eslint-disable prefer-rest-params */
+/* eslint-disable no-underscore-dangle */
+import { IDisposable } from '../../interface';
+
+/**
+ * @description 创建一个只能执行一次的包装函数
+ * @export
+ * @template T 函数类型
+ * @param {unknown} this 函数执行上下文
+ * @param {T} fn 需要包装的原始函数
+ * @returns {*}  {T} 包装后的函数，只会执行一次原始函数
+ */
+export function once<T extends Function>(this: unknown, fn: T): T {
+  const _this = this;
+  let didCall = false;
+  let result: unknown;
+
+  return function () {
+    if (didCall) {
+      return result;
+    }
+
+    didCall = true;
+    result = fn.apply(_this, arguments);
+
+    return result;
+  } as unknown as T;
+}
+
+/**
+ * @description 将普通函数转换为一次性可销毁对象
+ * @export
+ * @param {() => void} fn 需要转换的函数
+ * @returns {*}  {IDisposable} 可销毁对象
+ */
+export function toDisposable(fn: () => void): IDisposable {
+  const self = {
+    dispose: once(() => {
+      fn();
+    }),
+  };
+  return self;
+}
+
+/**
+ * @description 函数防抖
+ * @export
+ * @param {((...args: unknown[]) => void | Promise<void>)} func 要执行的函数
+ * @param {number} wait 延迟时间（毫秒）
+ * @param {boolean} [immediate] 是否立即执行
+ * @returns {*}  {(...args: unknown[]) => void} 包装后的防抖函数
+ */
+export function debounce(
+  func: (...args: unknown[]) => void | Promise<void>,
+  wait: number,
+  immediate?: boolean,
+): (...args: unknown[]) => void {
+  let timer: unknown;
+
+  return function (this: unknown, ...args: unknown[]): void {
+    if (timer) {
+      clearTimeout(timer as number);
+    }
+    if (immediate) {
+      const callNow = !timer;
+      timer = setTimeout(() => {
+        timer = null;
+      }, wait);
+      if (callNow) {
+        func.apply(this, args);
+      }
+    } else {
+      timer = setTimeout(() => {
+        func.apply(this, args);
+      }, wait);
+    }
+  };
+}
+
+/**
+ * @description 节流函数，限制函数在指定时间间隔内只能执行一次
+ * @export
+ * @param {((...args: unknown[]) => void | Promise<void>)} fn 要执行的函数
+ * @param {number} wait 节流时间间隔（毫秒）
+ * @returns {*}  {(...args: unknown[]) => void} 包装后的节流函数
+ */
+export function throttle(
+  fn: (...args: unknown[]) => void | Promise<void>,
+  wait: number,
+): (...args: unknown[]) => void {
+  let timer: unknown = null;
+  return function (this: unknown, ...args: unknown[]): void {
+    if (!timer) {
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+        timer = null;
+      }, wait);
+    }
+  };
+}

package/src/constant/core/core.ts

@@ -0,0 +1,54 @@
+/**
+ * @description 核心全局静态变量
+ * @export
+ * @class CoreConst
+ */
+export class CoreConst {
+  /**
+   * @description 默认模型服务标识
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly DEFAULT_MODEL_SERVICE_TAG = 'default';
+
+  /**
+   * @description 访问令牌标识
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly TOKEN = 'ibzuaa-token';
+
+  /**
+   * @description 刷新令牌标识
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly REFRESH_TOKEN = 'ibzuaa-refresh-token';
+
+  /**
+   * @description 访问令牌标识过期时间
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly TOKEN_EXPIRES = 'ibzuaa-token-expires';
+
+  /**
+   * @description 认证信息是走记住我模式的 cookie 标识
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly TOKEN_REMEMBER = 'ibizuaa-token-remember';
+
+  /**
+   * @description 是否是匿名用户登录的 cookie 标识
+   * @static
+   * @memberof CoreConst
+   */
+  static readonly IS_ANONYMOUS = 'ibizuaa-is-anonymous';
+
+  /**
+   * @description 存储访问相关数据键的集合名称
+   * @static
+   */
+  static readonly ACCESS_STORE_AREA_KEYS = 'ibizuaa-access-store-area-keys';
+}