@zk-tech/bedrock 0.0.1

package/src/sprintf/sprintf.test.ts

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,181 @@
+/* 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

@@ -0,0 +1,105 @@
+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

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

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

@@ -0,0 +1,74 @@
+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();
+  });
+});

package/src/structure/linked-list.ts

@@ -0,0 +1,145 @@
+class ListNode<T> {
+  constructor(
+    public value: T,
+    public next: ListNode<T> | null = null,
+    public prev: ListNode<T> | null = null,
+  ) {}
+}
+
+export class LinkedList<T> {
+  protected _head: ListNode<T> | null = null;
+  protected _tail: ListNode<T> | null = null;
+  protected _count = 0;
+
+  public get size(): number {
+    return this._count;
+  }
+
+  public get firstNode(): ListNode<T> | null {
+    return this._head;
+  }
+
+  public isEmpty(): boolean {
+    return this._head === null;
+  }
+
+  public clear(): void {
+    let current = this._head;
+    while (current !== null) {
+      const next = current.next;
+      current.prev = null;
+      current.next = null;
+      current = next;
+    }
+
+    this._head = null;
+    this._tail = null;
+    this._count = 0;
+  }
+
+  public unshift(value: T): LinkedList<T> {
+    const node = new ListNode(value);
+
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldHead = this._head;
+      this._head = node;
+      node.next = oldHead;
+      oldHead!.prev = node;
+    }
+
+    this._count++;
+    return this;
+  }
+
+  public push(value: T): LinkedList<T> {
+    const node = new ListNode(value);
+
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldTail = this._tail;
+      this._tail = node;
+      node.prev = oldTail;
+      oldTail!.next = node;
+    }
+
+    this._count++;
+    return this;
+  }
+
+  public shift(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    const node = this._head!;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+
+  public pop(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    const node = this._tail!;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+
+  public toArray(): T[] {
+    const result: T[] = [];
+    for (const value of this) {
+      result.push(value);
+    }
+    return result;
+  }
+
+  public *[Symbol.iterator](): Iterator<T> {
+    let current = this._head;
+    while (current !== null) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+
+  protected _remove(node: ListNode<T>): void {
+    // 如果节点已经被移除（prev 和 next 都为 null），直接返回
+    if (node.prev === null && node.next === null && node !== this._head && node !== this._tail) {
+      return;
+    }
+
+    // 更新链表头尾指针
+    if (node === this._head) {
+      this._head = node.next;
+      if (this._head) {
+        this._head.prev = null;
+      }
+    }
+    if (node === this._tail) {
+      this._tail = node.prev;
+      if (this._tail) {
+        this._tail.next = null;
+      }
+    }
+
+    // 更新相邻节点的引用
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+
+    // 清理被移除节点的引用
+    node.prev = null;
+    node.next = null;
+    this._count--;
+  }
+}