@zk-tech/bedrock 0.0.1 → 0.1.0

package/src/scheduler/index.ts

@@ -1,15 +0,0 @@
-// 任务调度优先级
-export { PriorityLevel } from './type';
-
-// 分片调度器
-export type { IChunkScheduler, IOptions as ISchedulerCallbackOptions } from './type';
-
-// 执行一个调度任务
-export { lvSchedulerCallback } from './lv-scheduler-callback';
-export type { ILvCallbackToken } from './lv-scheduler-callback';
-
-// 设置调度器配置
-export { lvSchedulerConfig } from './lv-scheduler-config';
-
-// 重置调度器配置
-export { lvSchedulerResetConfig } from './lv-scheduler-config';

package/src/scheduler/lv-scheduler-callback.ts

@@ -1,19 +0,0 @@
-import { type IDisposable } from '../dispose';
-import { getScheduler } from './core/scheduler';
-import type { IOptions, IScheduledCallback, PriorityLevel } from './type';
-import { makeTask } from './core/utils';
-import { CallbackToken } from './callback-token';
-
-export interface ILvCallbackToken extends IDisposable {
-  /**
-   * 更新优先级
-   */
-  updatePriorityLevel: (priorityLevel: PriorityLevel) => void;
-}
-
-export function lvSchedulerCallback(callback: IScheduledCallback, options: IOptions = {}): ILvCallbackToken {
-  const newTask = makeTask(callback, options);
-  getScheduler().addTask(newTask);
-
-  return new CallbackToken(newTask);
-}

package/src/scheduler/lv-scheduler-config.ts

@@ -1,17 +0,0 @@
-import { getScheduler } from './core/scheduler';
-import type { IConfig } from './type';
-
-export function lvSchedulerConfig(config: IConfig) {
-  if (config.fps !== undefined) {
-    getScheduler().executor.setFrameRate(config.fps);
-  }
-
-  if (config.enableInputPending !== undefined) {
-    getScheduler().setEnableInputPending(config.enableInputPending);
-  }
-}
-
-export function lvSchedulerResetConfig() {
-  getScheduler().executor.resetFrameRate();
-  getScheduler().setEnableInputPending(true);
-}

package/src/scheduler/type.ts

@@ -1,48 +0,0 @@
-// 任务调度的优先级，从高到低
-export enum PriorityLevel {
-  /** 立即执行任务的优先级 */
-  ImmediatePriority,
-  /** 用户阻塞的优先级 */
-  UserBlockingPriority,
-  /** 普通优先级 */
-  NormalPriority,
-  /** 低优先级 */
-  LowPriority,
-  /** 闲置优先级 */
-  IdlePriority,
-}
-
-export interface IOptions {
-  delay?: number;
-  priorityLevel?: PriorityLevel;
-}
-
-export interface IConfig {
-  fps?: number;
-  enableInputPending?: boolean;
-}
-
-export interface IScheduledCallback {
-  /**
-   * @param chunkScheduler 分片调度器
-   * @param didUserCallbackTimeout 该callback执行时，是否已经超过了注册时设置的过期时间
-   * @param remainingTime 该callback执行时，当前调度loop中剩余的可用时间
-   */
-  (chunkScheduler: IChunkScheduler, didUserCallbackTimeout: boolean, remainingTime: number): void;
-}
-
-/**
- * 分片调度器
- * 支持将某个大的宏任务，拆成小的粒度执行
- */
-export interface IChunkScheduler {
-  /**
-   * 在分片结束状态下，启动一个新的任务进入调度器
-   */
-  execute: (callback: IScheduledCallback, options?: IOptions) => void;
-
-  /**
-   * 在分片结束状态下，延续当前任务（本质上是立即执行任务）
-   */
-  continueExecute: (callback: IScheduledCallback) => void;
-}

package/src/sprintf/index.ts

@@ -1,2 +0,0 @@
-// 格式化字符串
-export { sprintf } from './sprintf';

package/src/sprintf/sprintf.test.ts

@@ -1,95 +0,0 @@
-import { sprintf } from './sprintf';
-
-describe('sprintf', () => {
-  it('case1', () => {
-    expect(sprintf('lvweb yyds!!')).toBe('lvweb yyds!!');
-  });
-
-  // 没有传递参数，不进入匹配模式
-  it('case2', () => {
-    expect(sprintf('lv%% %dweb yyds!!')).toBe('lv%% %dweb yyds!!');
-  });
-
-  // 匹配数值
-  it('case3', () => {
-    expect(sprintf('lvweb %d yyds!!', 666)).toBe('lvweb 666 yyds!!');
-  });
-
-  // 匹配非数值
-  it('case4', () => {
-    expect(sprintf('lvweb %d yyds!!', 'not number')).toBe('lvweb NaN yyds!!');
-  });
-
-  // 匹配浮点数
-  it('case5', () => {
-    expect(sprintf('lvweb %d yyds!!', 1.888)).toBe('lvweb 1.888 yyds!!');
-  });
-
-  // 匹配字符串
-  it('case6', () => {
-    expect(sprintf('lvweb %s yyds!!', 'dddd')).toBe('lvweb dddd yyds!!');
-  });
-
-  // 匹配布尔
-  it('case7', () => {
-    expect(sprintf('lvweb %b yyds!!', true)).toBe('lvweb true yyds!!');
-  });
-
-  // 匹配布尔
-  it('case8', () => {
-    expect(sprintf('lvweb %b yyds!!', false)).toBe('lvweb false yyds!!');
-  });
-
-  // 转义%
-  it('case9', () => {
-    expect(sprintf('lvweb %% %s yyds!!', 'run')).toBe('lvweb % run yyds!!');
-  });
-
-  // 匹配对象
-  it('case10', () => {
-    expect(sprintf('lvweb %v yyds!!', { foo: 'bar' })).toBe('lvweb {"foo":"bar"} yyds!!');
-  });
-
-  it('case11', () => {
-    expect(sprintf('lvweb %v yyds!!', 233)).toBe('lvweb 233 yyds!!');
-  });
-
-  it('case12', () => {
-    expect(sprintf('lvweb %v yyds!!', false)).toBe('lvweb false yyds!!');
-  });
-
-  it('case13', () => {
-    expect(sprintf('lvweb %v yyds!!', 'dddd')).toBe('lvweb "dddd" yyds!!');
-  });
-
-  // 匹配对象，序列化错误
-  it('case14', () => {
-    const a: { [key: string]: any } = {};
-    a.a = a;
-    expect(sprintf('lvweb %v yyds!!', a)).toBe('[invalid formatted message]lvweb %v yyds!!');
-  });
-
-  // 匹配很多
-  it('case15', () => {
-    expect(sprintf('lvweb %d %b %s %v!!', 233, true, 'yyds', { foo: 'bar' })).toBe(
-      'lvweb 233 true yyds {"foo":"bar"}!!',
-    );
-  });
-
-  // 参数数量对不上
-  it('case16', () => {
-    expect(sprintf('lvweb %d %b %s %s %v!!', 233, true, 'yyds', { foo: 'bar' })).toBe(
-      'lvweb 233 true yyds [object Object] undefined!!',
-    );
-  });
-
-  // 参数数量多了，多余部分追加
-  it('case17', () => {
-    expect(sprintf('lvweb', 233, true, 'yyds', { foo: 'bar' })).toBe('lvweb 233 true yyds [object Object]');
-  });
-
-  // 参数数量多了，多余部分追加
-  it('case18', () => {
-    expect(sprintf('lvweb %d!!', 233, true, 'yyds')).toBe('lvweb 233!! true yyds');
-  });
-});

package/src/sprintf/sprintf.ts

@@ -1,97 +0,0 @@
-import { lvAssertNotHere } from '../assert';
-
-const regex = {
-  text: /^[^\x25]+/, // \x25 是 % 的十六进制表示
-  modulo: /^\x25\x25/, // %%转义
-  placeholder: /^\x25([vVbBdDsS])/,
-};
-
-type ParseResult = (string | { placeholder: string })[];
-
-const cache = new Map<string, ParseResult>();
-
-function parse(str: string) {
-  const result: ParseResult = [];
-  if (cache.has(str)) {
-    return cache.get(str)!;
-  }
-  let sub = str;
-  while (sub) {
-    let match = regex.text.exec(sub);
-    if (match) {
-      result.push(match[0]);
-      sub = sub.substring(match[0].length);
-      continue;
-    }
-    match = regex.modulo.exec(sub);
-    if (match) {
-      result.push('%');
-      sub = sub.substring(match[0].length);
-      continue;
-    }
-
-    // 一定匹配到了占位符
-    match = regex.placeholder.exec(sub);
-    if (match && match.length > 1) {
-      result.push({
-        placeholder: match[1],
-      });
-      sub = sub.substring(match[0].length);
-    } else {
-      lvAssertNotHere();
-    }
-  }
-  cache.set(str, result);
-  return result;
-}
-
-function replace(parseResult: ParseResult, ...args: any[]) {
-  let message = '';
-  let index = 0;
-  for (const t of parseResult) {
-    if (typeof t === 'string') {
-      message += t;
-      continue;
-    }
-
-    if (args[index] === undefined) {
-      message += 'undefined';
-      continue;
-    }
-
-    switch (t.placeholder.toLowerCase()) {
-      case 's':
-        message += String(args[index++]);
-        break;
-      case 'd':
-        message += Number(args[index++] as number);
-        break;
-      case 'b':
-        message += args[index++] as boolean;
-        break;
-      case 'v':
-        message += JSON.stringify(args[index++]);
-        break;
-      default:
-        lvAssertNotHere();
-    }
-  }
-  for (; index < args.length; index++) {
-    message += ` ${args[index]}`;
-  }
-
-  return message;
-}
-
-export function sprintf(message: string, ...args: any[]) {
-  if (!args.length) {
-    return message;
-  }
-  try {
-    const parseResult = parse(message);
-    const formatted = replace(parseResult, ...args);
-    return formatted;
-  } catch (e) {
-    return `[invalid formatted message]${message}`;
-  }
-}

package/src/structure/graph.test.ts

@@ -1,181 +0,0 @@
-/* eslint-disable max-lines-per-function */
-import { Graph } from './graph';
-
-describe('Graph', () => {
-  let graph: Graph<string, string>;
-
-  beforeEach(() => {
-    graph = new Graph<string, string>((v) => v);
-  });
-
-  it('should create an empty graph', () => {
-    expect(graph.isEmpty()).toBe(true);
-    expect(graph.toString()).toBe('');
-  });
-
-  it('should add nodes to the graph', () => {
-    const nodeA = graph.lookupOrInsertNode('A');
-    const nodeB = graph.lookupOrInsertNode('B');
-    const nodeC = graph.lookupOrInsertNode('C');
-
-    expect(graph.isEmpty()).toBe(false);
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[]
-    
-      B
-        (-> incoming)[]
-        (outgoing ->)[]
-
-      C
-        (-> incoming)[]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    expect(nodeA).toBe(graph.lookup('A'));
-    expect(nodeB).toBe(graph.lookup('B'));
-    expect(nodeC).toBe(graph.lookup('C'));
-  });
-
-  it('should add edges to the graph', () => {
-    const nodeA = graph.lookupOrInsertNode('A');
-    const nodeB = graph.lookupOrInsertNode('B');
-    const nodeC = graph.lookupOrInsertNode('C');
-
-    graph.insertEdge(nodeA.data, nodeB.data);
-    graph.insertEdge(nodeA.data, nodeC.data);
-
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[B,C]
-      
-      B
-        (-> incoming)[A]
-        (outgoing ->)[]
-      
-      C
-        (-> incoming)[A]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-  });
-
-  it('should remove nodes and edges from the graph', () => {
-    const nodeA = graph.lookupOrInsertNode('A');
-    const nodeB = graph.lookupOrInsertNode('B');
-    const nodeC = graph.lookupOrInsertNode('C');
-    const nodeD = graph.lookupOrInsertNode('D');
-
-    expect(graph.isEmpty()).toBe(false);
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[]
-      
-      B
-        (-> incoming)[]
-        (outgoing ->)[]
-      
-      C
-        (-> incoming)[]
-        (outgoing ->)[]
-      
-      D
-        (-> incoming)[]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    graph.insertEdge(nodeA.data, nodeB.data);
-    graph.insertEdge(nodeA.data, nodeC.data);
-    graph.insertEdge(nodeB.data, nodeD.data);
-    graph.insertEdge(nodeC.data, nodeD.data);
-
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[B,C]
-      
-      B
-        (-> incoming)[A]
-        (outgoing ->)[D]
-      
-      C
-        (-> incoming)[A]
-        (outgoing ->)[D]
-      
-      D
-        (-> incoming)[B, C]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    graph.removeNode(nodeC.data);
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[B]
-      
-      B
-        (-> incoming)[A]
-        (outgoing ->)[D]
-      
-      D
-        (-> incoming)[B]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    graph.removeNode(nodeD.data);
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      A
-        (-> incoming)[]
-        (outgoing ->)[B]
-      
-      B
-        (-> incoming)[A]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    graph.removeNode(nodeA.data);
-    expect(graph.toString().replace(/\s/g, '')).toBe(
-      `
-      B
-        (-> incoming)[]
-        (outgoing ->)[]`.replace(/\s/g, ''),
-    );
-
-    graph.removeNode(nodeB.data);
-    expect(graph.isEmpty()).toBe(true);
-  });
-
-  it('should find the leafs of a graph', () => {
-    const nodeA = graph.lookupOrInsertNode('A');
-    const nodeB = graph.lookupOrInsertNode('B');
-    const nodeC = graph.lookupOrInsertNode('C');
-    const nodeD = graph.lookupOrInsertNode('D');
-
-    graph.insertEdge(nodeA.data, nodeB.data);
-    graph.insertEdge(nodeA.data, nodeC.data);
-    graph.insertEdge(nodeB.data, nodeD.data);
-    graph.insertEdge(nodeC.data, nodeD.data);
-
-    expect(graph.leafs().length).toBe(1);
-    expect(graph.leafs()[0].data).toBe(nodeD.data);
-
-    graph.removeNode(nodeA.data);
-
-    expect(graph.leafs().length).toBe(1);
-    expect(graph.leafs()[0].data).toBe(nodeD.data);
-
-    graph.removeNode(nodeD.data);
-
-    expect(graph.leafs().length).toBe(2);
-    expect(graph.leafs()[0].data).toBe(nodeB.data);
-    expect(graph.leafs()[1].data).toBe(nodeC.data);
-  });
-});

package/src/structure/graph.ts

@@ -1,105 +0,0 @@
-class Node<K, T> {
-  readonly incoming = new Map<K, Node<K, T>>();
-  readonly outgoing = new Map<K, Node<K, T>>();
-
-  constructor(
-    public key: K,
-    public data: T,
-  ) {}
-}
-
-export class Graph<K, T> {
-  private readonly _nodes = new Map<K, Node<K, T>>();
-
-  constructor(private readonly _hashFn: (element: T) => K) {}
-
-  // 寻找所有的叶子节点
-  public leafs(): Node<K, T>[] {
-    const ret: Node<K, T>[] = [];
-    for (const node of this._nodes.values()) {
-      if (node.outgoing.size === 0) {
-        ret.push(node);
-      }
-    }
-    return ret;
-  }
-
-  // 插入一条边
-  public insertEdge(from: T, to: T): void {
-    const fromNode = this.lookupOrInsertNode(from);
-    const toNode = this.lookupOrInsertNode(to);
-
-    fromNode.outgoing.set(toNode.key, toNode);
-    toNode.incoming.set(fromNode.key, fromNode);
-  }
-
-  // 移除某个节点
-  public removeNode(data: T): void {
-    const key = this._hashFn(data);
-    this._nodes.delete(key);
-    for (const node of this._nodes.values()) {
-      node.outgoing.delete(key);
-      node.incoming.delete(key);
-    }
-  }
-
-  // 查找某个节点
-  public lookup(data: T): Node<K, T> | undefined {
-    return this._nodes.get(this._hashFn(data));
-  }
-
-  // 查找某个节点，不存在则插入
-  public lookupOrInsertNode(data: T): Node<K, T> {
-    const key = this._hashFn(data);
-    let node = this._nodes.get(key);
-
-    if (!node) {
-      node = new Node(key, data);
-      this._nodes.set(key, node);
-    }
-
-    return node;
-  }
-
-  public isEmpty(): boolean {
-    return this._nodes.size === 0;
-  }
-
-  public toString(): string {
-    const data: string[] = [];
-    for (const [key, value] of this._nodes) {
-      data.push(
-        `${key}\n\t(-> incoming)[${[...value.incoming.keys()].join(', ')}]\n\t(outgoing ->)[${[
-          ...value.outgoing.keys(),
-        ].join(',')}]\n`,
-      );
-    }
-    return data.join('\n');
-  }
-
-  public findCycleSlow() {
-    for (const [id, node] of this._nodes) {
-      const seen = new Set<K>([id]);
-      const res = this._findCycle(node, seen);
-      if (res) {
-        return res;
-      }
-    }
-    return undefined;
-  }
-
-  private _findCycle(node: Node<K, T>, seen: Set<K>): string | undefined {
-    for (const [id, outgoing] of node.outgoing) {
-      if (seen.has(id)) {
-        return [...seen, id].join(' -> ');
-      }
-      seen.add(id);
-      const value = this._findCycle(outgoing, seen);
-      if (value) {
-        return value;
-      }
-      seen.delete(id);
-    }
-    return undefined;
-  }
-}

package/src/structure/index.ts

@@ -1,8 +0,0 @@
-// 有向图
-export { Graph } from './graph';
-
-// 双向链表
-export { LinkedList } from './linked-list';
-
-// 小顶堆
-export { MinHeap } from './min-heap';

package/src/structure/linked-list.test.ts

@@ -1,74 +0,0 @@
-import { LinkedList } from './linked-list';
-
-describe('LinkedList', () => {
-  let list: LinkedList<number>;
-
-  beforeEach(() => {
-    list = new LinkedList<number>();
-  });
-
-  it('isEmpty should return true for an empty list', () => {
-    expect(list.isEmpty()).toBe(true);
-  });
-
-  it('isEmpty should return false when the list contains elements', () => {
-    list.push(1);
-
-    expect(list.isEmpty()).toBe(false);
-  });
-
-  it('clear should remove all elements from the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-    list.clear();
-
-    expect(list.isEmpty()).toBe(true);
-  });
-
-  it('unshift should add elements to the front of the list', () => {
-    list.unshift(1);
-    list.unshift(2);
-    list.unshift(3);
-
-    expect(list.toArray()).toEqual([3, 2, 1]);
-  });
-
-  it('push should add elements to the end of the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-
-    expect(list.toArray()).toEqual([1, 2, 3]);
-  });
-
-  it('shift should remove and return the first element of the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-
-    const value = list.shift();
-    expect(value).toBe(1);
-    expect(list.toArray()).toEqual([2, 3]);
-  });
-
-  it('shift should return undefined for an empty list', () => {
-    const value = list.shift();
-    expect(value).toBeNull();
-  });
-
-  it('pop should remove and return the last element of the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-
-    const value = list.pop();
-    expect(value).toBe(3);
-    expect(list.toArray()).toEqual([1, 2]);
-  });
-
-  it('pop should return undefined for an empty list', () => {
-    const value = list.pop();
-    expect(value).toBeNull();
-  });
-});