@zk-tech/bedrock 0.0.1 → 0.0.2

package/src/undo-redo-stack/action-stack.test.ts

@@ -1,330 +0,0 @@
-import type { IActionStackElement } from './element';
-import { BaseActionUndoRedoStack } from './action-stack';
-
-class Data implements IActionStackElement {
-  constructor(
-    private readonly _undo: () => void,
-    private readonly _redo: () => void,
-  ) {}
-
-  undo() {
-    this._undo();
-  }
-
-  redo() {
-    this._redo();
-  }
-}
-
-describe('BaseActionUndoRedoStack', () => {
-  // 默认情况不能undo
-  it('canUndo1', () => {
-    const stack = new BaseActionUndoRedoStack();
-    expect(stack.canUndo()).toBeFalsy();
-  });
-
-  // 有了数据，可以undo
-  it('canUndo2', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    expect(stack.canUndo()).toBeTruthy();
-  });
-
-  // 有数据，但是被undo过了
-  it('canUndo3', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    stack.undo();
-    expect(stack.canUndo()).toBeFalsy();
-  });
-
-  // 默认情况不能redo
-  it('canRedo1', () => {
-    const stack = new BaseActionUndoRedoStack();
-    expect(stack.canRedo()).toBeFalsy();
-  });
-
-  // 添加了数据，还是不能redo
-  it('canRedo2', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    expect(stack.canRedo()).toBeFalsy();
-  });
-
-  // undo过了，可以redo
-  it('canRedo3', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    stack.undo();
-    expect(stack.canRedo()).toBeTruthy();
-  });
-
-  // 本来可以redo，但是添加了新数据
-  it('canRedo4', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    stack.undo();
-    expect(stack.canRedo()).toBeTruthy();
-    stack.pushElement(elem);
-    expect(stack.canRedo()).toBeFalsy();
-  });
-
-  it('pushElements', () => {
-    const stack = new BaseActionUndoRedoStack(2);
-    const fn = vi.fn();
-    stack.onStackChange(fn);
-    const elem1 = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem1);
-    expect(fn).toBeCalledTimes(1);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(1);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(0);
-
-    const elem2 = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem2);
-    expect(fn).toBeCalledTimes(2);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(2);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(0);
-
-    stack.undo();
-    expect(fn).toBeCalledTimes(3);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(1);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(1);
-
-    const elem3 = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem3);
-    expect(fn).toBeCalledTimes(4);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(2);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(0);
-
-    const elem4 = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem4);
-    expect(fn).toBeCalledTimes(5);
-    // 命中了最大限制，长度还是2个
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(2);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'][1]).toBe(elem4);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'][0]).toBe(elem3);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(0);
-  });
-
-  // 没有数据时候undo
-  it('undo1', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidUndo(fn);
-    stack.undo();
-    expect(fn).toBeCalledTimes(0);
-  });
-
-  // 有数据时候undo
-  it('undo2', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidUndo(fn);
-    const undoFn = vi.fn();
-    const redoFn = vi.fn();
-    const elem = new Data(undoFn, redoFn);
-    stack.pushElement(elem);
-    stack.undo();
-    expect(fn).toBeCalledTimes(1);
-    expect(undoFn).toBeCalledTimes(1);
-    expect(redoFn).toBeCalledTimes(0);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(0);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(1);
-  });
-
-  // 没有数据时候redo
-  it('redo1', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidUndo(fn);
-    stack.redo();
-    expect(fn).toBeCalledTimes(0);
-  });
-
-  // 有数据时候redo
-  it('redo2', () => {
-    const stack = new BaseActionUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidRedo(fn);
-    const undoFn = vi.fn();
-    const redoFn = vi.fn();
-    const elem = new Data(undoFn, redoFn);
-    stack.pushElement(elem);
-    stack.undo();
-    expect(fn).toBeCalledTimes(0);
-    expect(undoFn).toBeCalledTimes(1);
-    expect(redoFn).toBeCalledTimes(0);
-
-    stack.redo();
-    expect(fn).toBeCalledTimes(1);
-    expect(undoFn).toBeCalledTimes(1);
-    expect(redoFn).toBeCalledTimes(1);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_past'].length).toBe(1);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_future'].length).toBe(0);
-  });
-
-  it('clear', () => {
-    const fn = vi.fn();
-    const stack = new BaseActionUndoRedoStack();
-    stack.onStackChange(fn);
-
-    const undoFn = vi.fn();
-    const redoFn = vi.fn();
-    const elem = new Data(undoFn, redoFn);
-
-    // 本身没有元素，所以没有抛出事件
-    stack.clearRedo();
-    stack.clearUndo();
-    stack.reset();
-    expect(fn).toBeCalledTimes(0);
-
-    // 有undo元素，但是清除
-    stack.pushElement(elem);
-    fn.mockReset();
-    expect(stack.canUndo()).toBeTruthy();
-    stack.clearUndo();
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canUndo()).toBeFalsy();
-
-    // 有redo元素，但是清除
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.undo();
-    fn.mockReset();
-    expect(stack.canRedo()).toBeTruthy();
-    stack.clearRedo();
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canRedo()).toBeFalsy();
-
-    stack.undo();
-    expect(stack.canUndo()).toBeTruthy();
-    expect(stack.canRedo()).toBeTruthy();
-    fn.mockReset();
-    stack.reset();
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canUndo()).toBeFalsy();
-    expect(stack.canRedo()).toBeFalsy();
-  });
-});
-
-describe('DerivedUndoRedoStack', () => {
-  // 整一个奇怪的undoredostack，主要是测试复写基类方法
-  class UntrustedUndoRedoStack extends BaseActionUndoRedoStack<IActionStackElement> {
-    canUndo() {
-      return true;
-    }
-
-    canRedo() {
-      return true;
-    }
-
-    protected _popPastElements(): IActionStackElement[] {
-      const elems = [...this._past];
-      this._past.length = 0;
-      return elems;
-    }
-
-    protected _popFutureElements(): IActionStackElement[] {
-      const elems = [...this._future];
-      this._future.length = 0;
-      return elems;
-    }
-
-    protected _isOverflow(_elem: IActionStackElement) {
-      if (this._future.length > 0) {
-        return true;
-      }
-      return false;
-    }
-  }
-
-  // 虽然canUndo永远是true，但是undo没有真的触发，所以不会抛出事件
-  it('undo1', () => {
-    const stack = new UntrustedUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidUndo(fn);
-    stack.undo();
-    expect(fn).toBeCalledTimes(0);
-  });
-
-  // 验证_popPastElements重写成功
-  it('undo2', () => {
-    const stack = new UntrustedUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidUndo(fn);
-    const undoFn = vi.fn();
-    const redoFn = vi.fn();
-    const elem = new Data(undoFn, redoFn);
-    // 添加了三次
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.undo();
-    expect(fn).toBeCalledTimes(1);
-    expect(undoFn).toBeCalledTimes(3);
-    expect(redoFn).toBeCalledTimes(0);
-  });
-
-  // 虽然canRedo永远是true，但是redo没有真的触发，所以不会抛出事件
-  it('redo1', () => {
-    const stack = new UntrustedUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidRedo(fn);
-    stack.redo();
-    expect(fn).toBeCalledTimes(0);
-  });
-
-  // 验证_popFutureElements重写成功
-  it('redo2', () => {
-    const stack = new UntrustedUndoRedoStack();
-    const fn = vi.fn();
-    stack.onDidRedo(fn);
-    const undoFn = vi.fn();
-    const redoFn = vi.fn();
-    const elem = new Data(undoFn, redoFn);
-    // 添加了三次
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    stack.undo();
-    stack.redo();
-    expect(fn).toBeCalledTimes(1);
-    expect(undoFn).toBeCalledTimes(3);
-    expect(redoFn).toBeCalledTimes(3);
-  });
-
-  // 验证_isOverflow重写成功
-  it('isOverflow', () => {
-    const stack = new UntrustedUndoRedoStack(1);
-    const elem = new Data(vi.fn(), vi.fn());
-    stack.pushElement(elem);
-    stack.pushElement(elem);
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_isOverflow'](elem)).toBeFalsy();
-    stack.undo();
-    // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
-    expect(stack['_isOverflow'](elem)).toBeTruthy();
-  });
-});

package/src/undo-redo-stack/action-stack.ts

@@ -1,150 +0,0 @@
-import { Emitter, type Event } from '../event';
-import type { IActionStackElement } from './element';
-
-export class BaseActionUndoRedoStack<T extends IActionStackElement> {
-  // 当undo结束后触发
-  public onDidUndo: Event<[T[]]>;
-  // 当redo结束后触发
-  public onDidRedo: Event<[T[]]>;
-  // 当栈发生变化时触发
-  public onStackChange: Event<[]>;
-
-  protected readonly _past: T[] = [];
-  protected readonly _future: T[] = [];
-
-  protected _onDidUndo = new Emitter<[T[]]>();
-  protected _onDidRedo = new Emitter<[T[]]>();
-  protected _onStackChange = new Emitter<[]>();
-
-  constructor(protected readonly _limitSize = Infinity) {
-    this.onDidUndo = this._onDidUndo.event;
-    this.onDidRedo = this._onDidRedo.event;
-    this.onStackChange = this._onStackChange.event;
-  }
-
-  /**
-   * 进行撤销
-   *
-   * 注意：该方法不允许被子类重写
-   */
-  readonly undo = (): void => {
-    if (!this.canUndo()) {
-      return;
-    }
-    const elements = this._popPastElements();
-    if (elements.length <= 0) {
-      return;
-    }
-    for (const elem of elements) {
-      elem.undo();
-      this._future.push(elem);
-    }
-    this._onDidUndo.fire(elements);
-    this._onStackChange.fire();
-  };
-
-  /**
-   * 进行重做
-   *
-   * 注意：该方法不允许被子类重写
-   */
-  readonly redo = (): void => {
-    if (!this.canRedo()) {
-      return;
-    }
-    const elements = this._popFutureElements();
-    if (elements.length <= 0) {
-      return;
-    }
-    for (const elem of elements) {
-      elem.redo();
-      this._past.push(elem);
-    }
-    this._onDidRedo.fire(elements);
-    this._onStackChange.fire();
-  };
-
-  /**
-   * 追加操作进入栈中
-   *
-   * 注意：该方法不允许被子类重写
-   */
-  readonly pushElement = (element: T): void => {
-    this._future.length = 0;
-    if (this._isOverflow(element)) {
-      this._past.shift();
-    }
-    this._past.push(element);
-    this._onStackChange.fire();
-  };
-
-  /**
-   * 是否可以撤销。子类可以重写
-   */
-  public canUndo(): boolean {
-    return this._past.length > 0;
-  }
-
-  /**
-   * 是否可以重做。子类可以重写
-   */
-  public canRedo(): boolean {
-    return this._future.length > 0;
-  }
-
-  /**
-   * 清除undo
-   */
-  public clearUndo(): void {
-    if (this._past.length === 0) {
-      return;
-    }
-    this._past.length = 0;
-    this._onStackChange.fire();
-  }
-
-  /**
-   * 清除redo
-   */
-  public clearRedo(): void {
-    if (this._future.length === 0) {
-      return;
-    }
-    this._future.length = 0;
-    this._onStackChange.fire();
-  }
-
-  /**
-   * 重置栈
-   * 清空undo和redo
-   */
-  public reset(): void {
-    if (this._past.length === 0 && this._future.length === 0) {
-      return;
-    }
-    this._past.length = 0;
-    this._future.length = 0;
-    this._onStackChange.fire();
-  }
-
-  /**
-   * 在undo时找出Past中的元素。子类可以重写
-   */
-  protected _popPastElements(): T[] {
-    return this._past.length ? [this._past.pop()!] : [];
-  }
-
-  /**
-   * 在redo时找出Future中的元素。子类可以重写
-   */
-  protected _popFutureElements(): T[] {
-    return this._future.length ? [this._future.pop()!] : [];
-  }
-
-  /**
-   * 判断新添加元素，是否会超出栈的大小。子类可以重写
-   */
-  protected _isOverflow(_elem: T) {
-    return this._past.length >= this._limitSize;
-  }
-}

package/src/undo-redo-stack/element.ts

@@ -1,4 +0,0 @@
-export interface IActionStackElement {
-  undo: () => void;
-  redo: () => void;
-}

package/src/undo-redo-stack/index.ts

@@ -1,7 +0,0 @@
-// 基础的行为undoredo栈
-export { BaseActionUndoRedoStack } from './action-stack';
-// 行为undoredo栈中基础的元素接口
-export type { IActionStackElement } from './element';
-
-// 状态undoredo栈
-export { StateUndoRedoStack } from './state-stack';

package/src/undo-redo-stack/state-stack.test.ts

@@ -1,118 +0,0 @@
-import { StateUndoRedoStack } from './state-stack';
-
-describe('StateUndoRedoStack', () => {
-  it('undo', () => {
-    const fn = vi.fn();
-    const stack = new StateUndoRedoStack<string>('initial');
-    stack.onDidRedo(fn);
-    stack.onDidUndo(fn);
-    expect(stack.currentState).toBe('initial');
-    expect(stack.canUndo()).toBeFalsy();
-    expect(stack.canUndo()).toBeFalsy();
-
-    stack.pushElement('1');
-    stack.pushElement('2');
-    stack.pushElement('3');
-    expect(stack.currentState).toBe('3');
-
-    stack.undo();
-    expect(stack.currentState).toBe('2');
-    expect(fn).toBeCalledWith('2');
-
-    stack.undo();
-    expect(stack.currentState).toBe('1');
-    expect(fn).toBeCalledWith('1');
-
-    stack.undo();
-    expect(stack.currentState).toBe('initial');
-    expect(fn).toBeCalledWith('initial');
-    expect(stack.canUndo()).toBeFalsy();
-  });
-
-  it('redo', () => {
-    const fn = vi.fn();
-    const stack = new StateUndoRedoStack<string>('initial');
-    stack.onDidRedo(fn);
-    stack.onDidUndo(fn);
-    expect(stack.currentState).toBe('initial');
-    expect(stack.canUndo()).toBeFalsy();
-    expect(stack.canUndo()).toBeFalsy();
-
-    stack.pushElement('1');
-    stack.pushElement('2');
-    stack.pushElement('3');
-
-    stack.undo();
-    expect(stack.currentState).toBe('2');
-    expect(fn).toBeCalledWith('2');
-    expect(stack.canRedo()).toBeTruthy();
-
-    stack.redo();
-    expect(stack.canRedo()).toBeFalsy();
-    expect(stack.currentState).toBe('3');
-    expect(fn).toBeCalledWith('3');
-
-    stack.undo();
-    stack.undo();
-    expect(stack.currentState).toBe('1');
-    expect(fn).toBeCalledWith('1');
-    expect(stack.canRedo()).toBeTruthy();
-
-    stack.pushElement('4');
-    expect(stack.canRedo()).toBeFalsy();
-
-    stack.undo();
-    expect(stack.currentState).toBe('1');
-    expect(fn).toBeCalledWith('1');
-    expect(stack.canRedo()).toBeTruthy();
-
-    stack.redo();
-    expect(stack.canRedo()).toBeFalsy();
-    expect(stack.currentState).toBe('4');
-    expect(fn).toBeCalledWith('4');
-  });
-
-  it('clear', () => {
-    const fn = vi.fn();
-    const stack = new StateUndoRedoStack<string>('initial');
-    stack.onStackChange(fn);
-
-    // 本身没有元素，所以没有抛出事件
-    stack.clearRedo();
-    stack.clearUndo();
-    stack.reset('initial');
-    expect(fn).toBeCalledTimes(0);
-
-    // reset后的state不一样，所以会触发回调
-    stack.reset('initial2');
-    expect(fn).toBeCalledTimes(1);
-
-    // 有undo元素，但是清除
-    stack.pushElement('1');
-    fn.mockReset();
-    expect(stack.canUndo()).toBeTruthy();
-    stack.clearUndo();
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canUndo()).toBeFalsy();
-
-    // 有redo元素，但是清除
-    stack.pushElement('1');
-    stack.pushElement('2');
-    stack.pushElement('3');
-    stack.undo();
-    fn.mockReset();
-    expect(stack.canRedo()).toBeTruthy();
-    stack.clearRedo();
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canRedo()).toBeFalsy();
-
-    stack.undo();
-    expect(stack.canUndo()).toBeTruthy();
-    expect(stack.canRedo()).toBeTruthy();
-    fn.mockReset();
-    stack.reset('initial');
-    expect(fn).toBeCalledTimes(1);
-    expect(stack.canUndo()).toBeFalsy();
-    expect(stack.canRedo()).toBeFalsy();
-  });
-});