@zk-tech/bedrock 0.0.1 → 0.0.2

package/src/structure/linked-list.ts

@@ -1,145 +0,0 @@
-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--;
-  }
-}

package/src/structure/min-heap.test.ts

@@ -1,71 +0,0 @@
-import { MinHeap } from './min-heap';
-
-describe('MinHeap', () => {
-  let heap: MinHeap<number>;
-
-  beforeEach(() => {
-    heap = new MinHeap();
-  });
-
-  test('insert adds a value and sifts it up the heap', () => {
-    heap.insert(2);
-    expect(heap.peek()).toEqual(2);
-
-    heap.insert(3);
-    expect(heap.peek()).toEqual(2);
-
-    heap.insert(1);
-    expect(heap.peek()).toEqual(1);
-  });
-
-  test('peek returns the minimum value without removing it', () => {
-    expect(heap.peek()).toBeNull();
-
-    heap.insert(1);
-    expect(heap.peek()).toEqual(1);
-
-    heap.insert(0);
-    expect(heap.peek()).toEqual(0);
-
-    heap.remove();
-    expect(heap.peek()).toEqual(1);
-  });
-
-  test('remove extracts the minimum value and returns it', () => {
-    expect(heap.remove()).toBeNull();
-
-    heap.insert(2);
-    heap.insert(3);
-    heap.insert(1);
-
-    expect(heap.remove()).toBe(1);
-    expect(heap.remove()).toBe(2);
-    expect(heap.remove()).toBe(3);
-    expect(heap.remove()).toBeNull();
-  });
-
-  test('size returns the number of elements in the heap', () => {
-    expect(heap.size()).toBe(0);
-
-    heap.insert(2);
-    heap.insert(3);
-    expect(heap.size()).toBe(2);
-
-    heap.remove();
-    expect(heap.size()).toBe(1);
-  });
-
-  test('heap maintains the heap property on inserts and removes', () => {
-    heap.insert(3);
-    heap.insert(4);
-    heap.insert(5);
-    heap.insert(1);
-    heap.insert(2);
-
-    expect(heap.remove()).toEqual(1);
-    expect(heap.remove()).toEqual(2);
-    expect(heap.remove()).toEqual(3);
-    expect(heap.remove()).toEqual(4);
-    expect(heap.remove()).toEqual(5);
-  });
-});

package/src/structure/min-heap.ts

@@ -1,91 +0,0 @@
-export class MinHeap<T> {
-  private readonly _heap: T[] = [];
-  private readonly _compare: (a: T, b: T) => number;
-
-  constructor(compareFunction?: (a: T, b: T) => number) {
-    if (compareFunction) {
-      this._compare = compareFunction;
-    } else {
-      this._compare = (a, b) => {
-        if (a < b) return -1;
-        if (a > b) return 1;
-        return 0;
-      };
-    }
-  }
-
-  public insert(value: T): void {
-    this._heap.push(value);
-    this._siftUp();
-  }
-
-  public peek(): T | null {
-    return this._heap.length > 0 ? this._heap[0] : null;
-  }
-
-  public remove(): T | null {
-    if (this._heap.length === 0) return null;
-    if (this._heap.length === 1) return this._heap.pop()!;
-
-    const item = this._heap[0];
-    this._heap[0] = this._heap.pop()!;
-    this._siftDown();
-    return item;
-  }
-
-  public size(): number {
-    return this._heap.length;
-  }
-
-  public clear(): void {
-    this._heap.length = 0;
-  }
-
-  private _getLeftChildIndex(parentIndex: number): number {
-    return 2 * parentIndex + 1;
-  }
-
-  private _getRightChildIndex(parentIndex: number): number {
-    return 2 * parentIndex + 2;
-  }
-
-  private _getParentIndex(childIndex: number): number {
-    return Math.floor((childIndex - 1) / 2);
-  }
-
-  private _swap(indexOne: number, indexTwo: number): void {
-    [this._heap[indexOne], this._heap[indexTwo]] = [this._heap[indexTwo], this._heap[indexOne]];
-  }
-
-  private _siftUp(): void {
-    let index = this._heap.length - 1;
-    while (index > 0 && this._compare(this._heap[this._getParentIndex(index)], this._heap[index]) > 0) {
-      const parentIndex = this._getParentIndex(index);
-      this._swap(index, parentIndex);
-      index = parentIndex;
-    }
-  }
-
-  private _siftDown(): void {
-    let index = 0;
-    let smallerChildIndex = this._getLeftChildIndex(index);
-
-    while (smallerChildIndex < this._heap.length) {
-      const rightChildIndex = this._getRightChildIndex(index);
-      if (
-        rightChildIndex < this._heap.length &&
-        this._compare(this._heap[rightChildIndex], this._heap[smallerChildIndex]) < 0
-      ) {
-        smallerChildIndex = rightChildIndex;
-      }
-
-      if (this._compare(this._heap[index], this._heap[smallerChildIndex]) <= 0) {
-        break;
-      }
-
-      this._swap(index, smallerChildIndex);
-      index = smallerChildIndex;
-      smallerChildIndex = this._getLeftChildIndex(index);
-    }
-  }
-}

package/src/type/REAME.md

@@ -1,2 +0,0 @@
-# Typescript typing
-定义项目内用到的 typescript 高级类型

package/src/type/distributive-omit.interface.ts

@@ -1,4 +0,0 @@
-// Typescript 提供的 Omit 函数会导致联合结构丢失，额外包装实现
-// https://stackoverflow.com/questions/57103834/typescript-omit-a-property-from-all-interfaces-in-a-union-but-keep-the-union-s/57103940#57103940
-
-export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;

package/src/type/index.ts

@@ -1,3 +0,0 @@
-export type { DistributiveOmit } from './distributive-omit.interface';
-
-export type { ObjectKeyPaths, ValueAtPath } from './object-key-paths.interface';

package/src/type/object-key-paths.interface.ts

@@ -1,40 +0,0 @@
-/**
- * 提取对象的 key 用 . 拼接成 path 形式
- * type T1 = ObjectKeyPaths<{ name: string; age: number }>; // expected to be 'name' | 'age'
- * type T2 = ObjectKeyPaths<{
- *    refCount: number;
- *    person: { name: string; age: number };
- *  }>; // expected to be 'refCount' | 'person' | 'person.name' | 'person.age'
- */
-
-type GenNode<K extends string | number, IsRoot extends boolean> = IsRoot extends true
-  ? `${K}`
-  : `.${K}` | (K extends number ? `[${K}]` : never);
-
-export type ObjectKeyPaths<
-  T extends Record<string, unknown>,
-  IsRoot extends boolean = true,
-  K extends keyof T = keyof T,
-> = K extends string | number
-  ?
-      | GenNode<K, IsRoot>
-      | (T[K] extends Record<string, unknown> ? `${GenNode<K, IsRoot>}${ObjectKeyPaths<T[K], false>}` : never)
-  : never;
-
-/**
- * 获取对象 path 对应的类型
- * type T = ValueAtPath<{ a: { b: number } }, 'a.b'>; // expected to be number
- */
-export type ValueAtPath<
-  T extends Record<string, unknown>, // 泛型类型参数 T 表示对象类型
-  P extends ObjectKeyPaths<T>, // 泛型类型参数 P 表示路径字符串，必须是 T 可能存在的所有路径之一
-> = P extends `${infer K}.${infer R}` // 如果 P 包含 "." 分隔符，则将其拆分成两部分 K 和 R
-  ? K extends keyof T // 如果 K 是 T 的属性之一
-    ? T[K] extends Record<string, unknown>
-      ? // @ts-ignore
-        ValueAtPath<T[K], R> // 递归地获取 T[K] 对应的子对象中的 R 路径属性的值
-      : never // 否则返回 never 类型（表示不存在）
-    : never
-  : P extends keyof T // 如果 P 不包含 "." 分隔符，并且是 T 的属性之一
-    ? T[P] // 直接返回 T 中对应属性的值
-    : never; // 否则返回 never 类型（表示不存在）

package/src/undo-redo-stack/README.md

@@ -1,61 +0,0 @@
-# UndoRedo栈
-提供了基础的undoredo栈规范，具体业务方可以直接使用或者继承使用。  
-
-## StateUndoRedoStack
-state形式undoredo栈的实现，类似Redux这种形式，使用方只需要消费当前的state。  
-```
-// 用法举例
-const stack = new StateUndoRedoStack<T>(initialState);
-
-stack.onDidRedo((state) => {
-  UI.reset(state);
-});
-stack.onDidUndo((state) => {
-  UI.reset(state);
-});
-
-```
-
-特点：
-- 每次只会有一个state变更，不会undo的时候，连续触发两个state行为。  
-- 不建议继承并重写方法，因为这种模式的undoRedoStack，本身就是简单场景使用。  
-
-## ActionUndoRedoStack
-action形式undoredo栈的实现，相比较state形式会复杂一些，业务方需要明确action存在undo和redo两种行为。
-
-### ActionStackElement
-action形式栈中的元素，需要使用方满足接口。  
-需要提供`undo`方法和`redo`方法即可。  
-下面是一个简单的`IActionStackElement`实现举例：  
-```
-class CommandElement<T> implement IUndoRedoElement {
-  private _currentCommand: T;
-  private _invertCommand: T;
-
-  undo() {
-    this._invertCommand.execute();
-    this._reverse();
-  }
-
-  redo() {
-    this._invertCommand.execute();
-    this._reverse();
-  }
-
-  private _reverse() {
-    swap(this._currentCommand, this._invertCommand);
-  }
-}
-```
-
-特点：  
-- 禁止继承时重写`undo`，`redo`，`pushElement`这三个方法，因为重写的话会影响生命周期行为。  
-- 提供默认的容量能力控制，可以重写`isOverflow`方法来业务精细化判断容量大小。
-- **可以复写`popPastElements`和`popFutureElements`来实现定制化的出栈逻辑。**
-
-
-## 其他
-- 如果需要其他生命周期，请联系基建侧同学。  
-- ActionUndoRedoStack中每一次undo、redo执行的粒度是数组，是因为业务场景中可能有联动出栈的情况。  
-- **如果本身是state场景，但是有一些复杂的逻辑，可以使用Action形式栈模拟。**  
-- Past、Future命名参考于vscode和redux。