@zk-tech/bedrock 0.0.1

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

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

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

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

@@ -0,0 +1,7 @@
+// 基础的行为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

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

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

@@ -0,0 +1,133 @@
+import type { Event } from '../event';
+import { Emitter } from '../event';
+
+export class StateUndoRedoStack<T> {
+  // 当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 _currentState: T,
+    protected readonly _limitSize = Infinity,
+  ) {
+    this.onDidUndo = this._onDidUndo.event;
+    this.onDidRedo = this._onDidRedo.event;
+    this.onStackChange = this._onStackChange.event;
+  }
+
+  get currentState() {
+    return this._currentState;
+  }
+
+  /**
+   * 进行撤销
+   */
+  public undo() {
+    if (!this.canUndo()) {
+      return;
+    }
+    this._future.push(this._currentState);
+    this._currentState = this._past.pop()!;
+    this._onDidUndo.fire(this._currentState);
+    this._onStackChange.fire();
+  }
+
+  /**
+   * 进行重做
+   *
+   * 注意：该方法不允许被子类重写
+   */
+  public redo() {
+    if (!this.canRedo()) {
+      return;
+    }
+    this._past.push(this._currentState);
+    this._currentState = this._future.pop()!;
+    this._onDidRedo.fire(this._currentState);
+    this._onStackChange.fire();
+  }
+
+  /**
+   * 追加操作进入栈中
+   *
+   * 注意：该方法不允许被子类重写
+   */
+  public pushElement(element: T) {
+    this._future.length = 0;
+    if (this._isOverflow(element)) {
+      this._past.shift();
+    }
+    if (this._currentState) {
+      this._past.push(this._currentState);
+    }
+    this._currentState = 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(state: T): void {
+    if (this._past.length === 0 && this._future.length === 0 && this._currentState === state) {
+      return;
+    }
+    this._past.length = 0;
+    this._future.length = 0;
+    this._currentState = state;
+    this._onStackChange.fire();
+  }
+
+  /**
+   * 判断新添加元素，是否会超出栈的大小
+   */
+  protected _isOverflow(_elem: T) {
+    return this._past.length >= this._limitSize;
+  }
+}

package/src/uuid/index.ts

@@ -0,0 +1,7 @@
+export { uuid } from './uuid';
+export { upperCaseUuid } from './uuid';
+
+export { generateUuid } from './uuid';
+export { generateUpperCaseUuid } from './uuid';
+
+export { isUuid } from './uuid';

package/src/uuid/uuid.ts

@@ -0,0 +1,86 @@
+declare const crypto:
+  | undefined
+  | {
+      // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#browser_compatibility
+      getRandomValues?: (data: Uint8Array) => Uint8Array;
+      // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID#browser_compatibility
+      randomUUID?: () => UuidString;
+    };
+
+const pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+type UuidString = `${string}-${string}-${string}-${string}-${string}`;
+
+/**
+ * 判断一个字符串，是否是标准的UUID
+ */
+export function isUuid(value: string): boolean {
+  return pattern.test(value);
+}
+
+/**
+ * 生成一个标准的UUID
+ */
+export const generateUuid = ((): (() => UuidString) => {
+  // 优先使用 randomUUID
+  if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID.bind(crypto);
+  }
+
+  // 其次尝试使用 randomValues
+  let getRandomValues: (bucket: Uint8Array) => Uint8Array;
+  if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  } else {
+    getRandomValues = function (bucket: Uint8Array): Uint8Array {
+      for (let i = 0; i < bucket.length; i++) {
+        bucket[i] = Math.floor(Math.random() * 256);
+      }
+      return bucket;
+    };
+  }
+
+  const data = new Uint8Array(16);
+  const hex: string[] = [];
+  for (let i = 0; i < 256; i++) {
+    hex.push(i.toString(16).padStart(2, '0'));
+  }
+
+  return (): UuidString => {
+    getRandomValues(data);
+
+    data[6] = (data[6] & 0x0f) | 0x40;
+    data[8] = (data[8] & 0x3f) | 0x80;
+
+    let i = 0;
+    let result = '';
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += '-';
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += '-';
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += '-';
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += '-';
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    return result as UuidString;
+  };
+})();
+
+/**
+ * 生成一个标准且字母大写的UUID
+ */
+export const generateUpperCaseUuid = () => generateUuid().toUpperCase();
+export const uuid = generateUuid;
+export const upperCaseUuid = generateUpperCaseUuid;

package/src/worker/cors-worker.ts

@@ -0,0 +1,38 @@
+/**
+ * 将 worker 转 inline worker 的帮助函数，为了性能考虑，SCM 会在构建线上项目时将资源依赖都打包上传到 cdn 处。
+ * 包括 worker.js，但是这种策略违反同源加载策略。所以为了应对这种问题，我们需要将 worker 进行强制内联处理.
+ *
+ * 由于 webpack AST 的约束限制.必须严格使用以下语法申明 worker：
+ * new Worker(new URL('xxx.js', import.meta.url)
+ * 字符上必须严格匹配。所以导入使用 CorsWorker 时，需要将其强行 alias
+ * import { CorsWorker as Worker } from '@byted-image/lv-bedrock/worker';
+ * )
+ */
+import type { IDisposable } from '@/dispose';
+
+export class CorsWorker implements IDisposable {
+  private readonly _worker: Worker;
+
+  constructor(url: string | URL) {
+    const absoluteUrl = new URL(url, window.location.href).toString();
+    const workerSource = `\
+	const urlString = ${JSON.stringify(absoluteUrl)}
+	const originURL = new URL(urlString)
+	const originalImportScripts = self.importScripts
+	self.importScripts = (url) => originalImportScripts.call(self, new URL(url, originURL).toString())
+	importScripts(urlString);
+	`;
+    const blob = new Blob([workerSource], { type: 'application/javascript' });
+    const objectURL = URL.createObjectURL(blob);
+    this._worker = new Worker(objectURL);
+    URL.revokeObjectURL(objectURL);
+  }
+
+  getWorker() {
+    return this._worker;
+  }
+
+  dispose(): void {
+    this._worker.terminate();
+  }
+}

package/src/worker/index.ts

@@ -0,0 +1,4 @@
+export { CorsWorker } from './cors-worker';
+export { PromiseWorkerWorkerThread } from './promise-worker-worker-thread';
+export { PromiseWorkerMainThread } from './promise-worker-main-thread';
+export type { PromiseWorkerRequest, PromiseWorkerResponse } from './promise-worker.interface';

package/src/worker/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.0.1","results":[[":promise-worker-main-thread.test.ts",{"duration":3,"failed":false}]]}

package/src/worker/promise-worker-main-thread.test.ts

@@ -0,0 +1,91 @@
+import { lvAssert } from '@/assert';
+import { PromiseWorkerMainThread } from './promise-worker-main-thread';
+
+class MockWebWorker {
+  public onmessage: ((e: MessageEvent) => void) | null = null;
+  public postMessage!: (message: any) => void;
+
+  constructor(postMessage: any) {
+    this.postMessage = postMessage;
+  }
+
+  triggerMessage(e: MessageEvent) {
+    this.onmessage!(e);
+  }
+
+  terminate() {
+    // ...
+  }
+}
+
+describe('promise-worker-main-thread', () => {
+  // 普通open
+  test('base1', async () => {
+    const fn1 = vi.fn();
+    const postMessageFn = vi.fn();
+
+    const worker = new MockWebWorker(postMessageFn);
+    worker.onmessage = fn1;
+    const mainThread = new PromiseWorkerMainThread(worker as any as Worker);
+
+    const task = {};
+    const defer = mainThread.sendTaskToWorker(task);
+    expect(postMessageFn).toBeCalledWith(expect.objectContaining(task));
+
+    const [firstArg] = postMessageFn.mock.calls[0];
+
+    const resp = {
+      pid: firstArg.pid,
+      code: 0,
+      data: 1,
+    };
+    const resp1 = {
+      pid: `${firstArg.pid}1111`,
+      code: 0,
+      data: 1,
+    };
+    // @ts-expect-error type error 不去模拟完整的 MessageEvent 对象了。就将就一个用到的数据结构算了
+    expect(() => worker.onmessage({ data: resp1 })).toThrowError();
+    expect(fn1).toBeCalledWith({ data: resp1 }); // 外面的监听正常触发
+
+    await new Promise(process.nextTick);
+
+    // @ts-expect-error type error
+    worker.onmessage({ data: resp });
+    expect(fn1).toBeCalledWith({ data: resp }); // 外面的监听正常触发
+    await new Promise(process.nextTick);
+
+    const res = await defer;
+    expect(res.ok).toBe(true);
+    lvAssert(res.ok)
+    expect(res.code).toBe(0);
+    expect(res.value).toBe(resp.data);
+  });
+
+  test('reject', async () => {
+    const fn1 = vi.fn();
+    const postMessageFn = vi.fn();
+
+    const worker = new MockWebWorker(postMessageFn);
+    worker.onmessage = fn1;
+    const mainThread = new PromiseWorkerMainThread(worker as any as Worker);
+
+    const task = {};
+    const defer = mainThread.sendTaskToWorker(task);
+    expect(postMessageFn).toBeCalledWith(expect.objectContaining(task));
+
+    const [firstArg] = postMessageFn.mock.calls[0];
+    const resp = {
+      pid: firstArg.pid,
+      code: -1,
+      msg: 'error',
+    };
+    // @ts-expect-error type error 不去模拟完整的 MessageEvent 对象了。就将就一个用到的数据结构算了
+    worker.onmessage({ data: resp });
+
+    const res = await defer;
+    expect(res.ok).toBe(false);
+    expect(res.code).toBe(-1);
+    expect(res.msg).toBe('error');
+  });
+});