@zk-tech/bedrock 0.0.1 → 0.1.0

package/src/dispose/tracker.ts

@@ -1,105 +0,0 @@
-import { Logger } from '@/_internal/logger';
-import type { IDisposable } from './dispose-base';
-import { EmptyDispose } from './dispose-base';
-
-export interface IDisposableTracker {
-  trackDisposable: (disposable: IDisposable) => void;
-
-  setParent: (child: IDisposable, parent: IDisposable | null) => void;
-
-  markAsDisposed: (disposable: IDisposable) => void;
-
-  markAsLeaked: (disposable: IDisposable) => void;
-}
-
-let disposableTracker: IDisposableTracker | null = null;
-
-function makeDefaultTracker() {
-  // reactHooks useEffect中出现disposable，我们默认为不会泄漏
-  // 默认使用者一定会在useEffect的返回值中进行dispose
-  const ignorePattern = /commitHookEffectList/i;
-
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const __is_disposable_tracked__ = '__is_disposable_tracked__';
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const __is_leak_marked__ = '__is_leak_marked__';
-  return new (class implements IDisposableTracker {
-    trackDisposable(x: IDisposable): void {
-      const stack = new Error('Potentially leaked disposable').stack!;
-      setTimeout(() => {
-        if (stack.match(ignorePattern)) {
-          return;
-        }
-        if ((x as any)[__is_leak_marked__]) {
-          return;
-        }
-        if (!(x as any)[__is_disposable_tracked__]) {
-          Logger.log(stack);
-        }
-      }, 3000);
-    }
-
-    setParent(child: IDisposable, parent: IDisposable | null): void {
-      if (child && child !== EmptyDispose) {
-        try {
-          (child as any)[__is_disposable_tracked__] = true;
-        } catch {
-          // noop
-        }
-      }
-    }
-
-    markAsDisposed(disposable: IDisposable): void {
-      if (disposable && disposable !== EmptyDispose) {
-        try {
-          (disposable as any)[__is_disposable_tracked__] = true;
-        } catch {
-          // noop
-        }
-      }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    markAsLeaked(disposable: IDisposable): void {
-      if (disposable && disposable !== EmptyDispose) {
-        try {
-          (disposable as any)[__is_leak_marked__] = true;
-        } catch {
-          // noop
-        }
-      }
-    }
-  })();
-}
-
-function setDisposableTracker(tracker: IDisposableTracker | null): void {
-  disposableTracker = tracker;
-}
-
-export function enableTrack(tracker: IDisposableTracker = makeDefaultTracker()) {
-  setDisposableTracker(tracker);
-}
-
-export function disableTrack() {
-  setDisposableTracker(null);
-}
-
-// 辅助能力 跟踪disposable
-export function TRACK_DISPOSABLE<T extends IDisposable>(x: T): T {
-  disposableTracker?.trackDisposable(x);
-  return x;
-}
-
-// 辅助能力 标记disposable成功
-export function MARK_AS_DISPOSED<T extends IDisposable>(x: T): void {
-  disposableTracker?.markAsDisposed(x);
-}
-
-// 辅助能力 标记disposable关系
-export function SET_PARENT_OF_DISPOSABLE(child: IDisposable, parent: IDisposable | null): void {
-  disposableTracker?.setParent(child, parent);
-}
-
-// 辅助能力 主动标记泄漏
-export function MARK_AS_LEAKED<T extends IDisposable>(x: T) {
-  disposableTracker?.markAsLeaked(x);
-}

package/src/error/error-base.ts

@@ -1,45 +0,0 @@
-//
-// lv项目中使用的错误类型
-//
-
-export type ILvErrorRef<K = unknown> = ILvErrorOr<never, K>;
-
-export interface ILvRealErrorRef<K = unknown> {
-  readonly ok: false;
-  readonly code: number;
-  readonly msg: string;
-  readonly cause?: ILvErrorRef | Error;
-  readonly toString: () => string;
-  readonly pair: () => [ILvRealErrorRef<K>, null];
-  readonly errorInfo?: K;
-
-  /**
-   * @deprecated 使用findJsError获取到jsError后再拿stack
-   */
-  readonly stack?: string;
-
-  /**
-   * 尽可能找到lvError对应的js错误
-   */
-  readonly findJsError: () => Error;
-}
-
-//
-// 没有错误时
-//
-type ILvValueRef<T> = {
-  readonly ok: true;
-  readonly code: 0;
-  readonly msg: '';
-  readonly cause?: undefined;
-  readonly value: T;
-  readonly toString: () => string;
-  readonly pair: () => [null, T];
-};
-
-//
-// lv项目中使用的携带值可能错误类型
-//
-export type ILvErrorOr<T, K = unknown> = (ILvRealErrorRef<K> | ILvValueRef<T>) & {
-  readonly pair: () => [null, T] | [ILvRealErrorRef<K>, null];
-};

package/src/error/error-code.ts

@@ -1,39 +0,0 @@
-import { lvErrorConst } from './error-const';
-
-/**
- * 提供了通用的错误码(+1至+256)
- *
- * 注意：这里只是提供了通用的错误码，方便服务使用，但并不是要求服务一定使用如下的错误码来表明某种错误
- */
-export enum GenericError {
-  Ok = 0,
-  Cancelled = 1, // 操作被取消
-  TimedOut = 2, // 操作超时
-  PermissionDenied = 3, // 无权限
-  AlreadyExists = 4, // 已经存在(文件/记录等)
-  NotSupported = 5, // 操作不支持
-  ResourceUnavailable = 6, // 资源不可用
-  OutOfRange = 7, // (参数/结果等)发生越界
-  InvalidArgument = 8, // 无效参数
-  NetworkFailed = 9, // 网络失败
-  Interrupted = 10, // 操作被中断(捕获异常转为错误)
-  ResultNil = 11, // 结果不存在(null or undefined转为错误)
-}
-
-/**
- * 通用错误码所对应的编译时常量对象(ErrorConst)
- */
-export const cancelledError = lvErrorConst(GenericError.Cancelled, 'operation(s) cancelled.');
-export const timeoutError = lvErrorConst(GenericError.TimedOut, 'operation(s) timed out.');
-export const permissionDeniedError = lvErrorConst(GenericError.PermissionDenied, 'permission denied.');
-export const alreadyExistsError = lvErrorConst(GenericError.AlreadyExists, 'already exists.');
-export const notSupportedError = lvErrorConst(GenericError.NotSupported, 'operation(s) not supported.');
-export const resourceUnavailableError = lvErrorConst(
-  GenericError.ResourceUnavailable,
-  'resource is unavailable.',
-);
-export const outOfRangeError = lvErrorConst(GenericError.OutOfRange, 'out of range.');
-export const invalidArgumentError = lvErrorConst(GenericError.InvalidArgument, 'invalid arguments.');
-export const networkFailedError = lvErrorConst(GenericError.NetworkFailed, 'network failed.');
-export const interruptedError = lvErrorConst(GenericError.Interrupted, 'interrupted.');
-export const resultNilError = lvErrorConst(GenericError.ResultNil, 'result is nil.');

package/src/error/error-const.test.ts

@@ -1,30 +0,0 @@
-import { lvErrorConst } from './error-const';
-
-const NETWORK_CODE = 404;
-const NETWORK_MSG = 'network error';
-
-const networkError = lvErrorConst(NETWORK_CODE, NETWORK_MSG);
-
-describe('LvErrorConst', () => {
-  test('creates runtime error', () => {
-    const err = networkError();
-    expect(err.ok).toBe(false);
-    expect(err.code).toBe(NETWORK_CODE);
-    expect(err.msg).toBe(NETWORK_MSG);
-    if (!err.ok) {
-      expect(err.code).toBe(NETWORK_CODE);
-      expect(err.msg).toBe(NETWORK_MSG);
-    }
-  });
-
-  test('creates runtime error with overridden message', () => {
-    const err = networkError('new error msg');
-    expect(err.ok).toBe(false);
-    expect(err.code).toBe(NETWORK_CODE);
-    expect(err.msg).toBe('new error msg');
-    if (!err.ok) {
-      expect(err.code).toBe(NETWORK_CODE);
-      expect(err.msg).toBe('new error msg');
-    }
-  });
-});

package/src/error/error-const.ts

@@ -1,16 +0,0 @@
-import { makeError, makeErrorBy } from './error-t';
-
-//
-// Error编译时错误对象
-//
-export function lvErrorConst(code: number, msg: string) {
-  return (rewrite?: string | Error) => {
-    if (!rewrite) {
-      return makeError(code, msg);
-    }
-    if (typeof rewrite === 'string') {
-      return makeError(code, rewrite);
-    }
-    return makeErrorBy(code, rewrite.message, rewrite);
-  };
-}

package/src/error/error-or.test.ts

@@ -1,44 +0,0 @@
-import type { ILvErrorOr } from './error-base';
-import { makeOkWith } from './error-or';
-
-describe('LvErrorOr', () => {
-  test('creates error without error state', () => {
-    const result = makeOkWith<number>(3);
-    expect(result.ok).toBe(true);
-    const [err, value] = result.pair();
-    try {
-      // @ts-expect-error Should fail at compile time because error data is used without checking state
-      expect(err.ok).toBe(true);
-    } catch (error) {
-      // err is undefined, ignore
-    }
-
-    // TODO: Should fail when using success data without checking state, but adding | null subtype is acceptable
-    expect(value).toBe(3);
-    if (!err) {
-      // State is checked as no error, should remove | null subtype here
-      value.toString();
-      expect(value).toBe(3);
-    }
-  });
-
-  test('creates error without error state', () => {
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const result = getData();
-    // @ts-expect-error Should fail at compile time, haven't checked if it's ok
-    const { value } = result;
-    void value;
-    if (result.ok) {
-      // State is checked as ok, can safely use value
-      result.value.toString();
-    }
-    if (!result.ok) {
-      // State is checked as not ok, can safely use error details
-      result.code.toString();
-    }
-
-    function getData(): ILvErrorOr<number> {
-      return makeOkWith(42);
-    }
-  });
-});

package/src/error/error-or.ts

@@ -1,2 +0,0 @@
-// makeOkWith 依赖内部 lvErrorRefSymbol，先放到 error-t 里面实现，有需要再拆分
-export { makeOkWith } from './error-t';

package/src/error/error-t.test.ts

@@ -1,116 +0,0 @@
-import type { ILvErrorOr } from './error-base';
-import { makeOkWith } from './error-or';
-import { isLvErrorRef, makeError, makeErrorBy, makeOk } from './error-t';
-
-const NETWORK_CODE = 404;
-const NETWORK_MSG = 'network error';
-
-describe('LvError', () => {
-  test('creates error without error state', () => {
-    const err = makeOk();
-    if (!err.ok) {
-      throw new Error('should be ok');
-    }
-    expect(err.ok).toBe(true);
-    void err.code;
-    // expect(err.code).toBe(0);
-    // For non-error state, toString content is undefined
-    expect(err.toString()).toBe('[object Object]');
-  });
-
-  test('error without error state supports destructuring', () => {
-    const result = makeOk();
-    const [err, value] = result.pair();
-    if (err) {
-      throw new Error('should be ok');
-    }
-    expect(err).toBe(null);
-    expect(value).toBe(null);
-  });
-
-  test('creates error with error state', () => {
-    const result = makeError(NETWORK_CODE, NETWORK_MSG);
-    expect(result.ok).toBe(false);
-
-    // Supports destructuring
-    const [err, value] = result.pair();
-    if (!err) {
-      throw new Error('should be error');
-    }
-    expect(err.code).toBe(NETWORK_CODE);
-    expect(err.msg).toBe(NETWORK_MSG);
-    expect(value).toBe(null);
-
-    // Supports getting cause
-    expect(result.toString()).toBe('[404]network error.');
-  });
-
-  test('creates error with cause', () => {
-    const err0 = new Error('original error');
-    const err1 = makeErrorBy(NETWORK_CODE, NETWORK_MSG, err0);
-    if (err1.ok) {
-      throw new Error('should be error');
-    }
-    const err2 = makeErrorBy(NETWORK_CODE, NETWORK_MSG, err1);
-    expect(err2.ok).toBe(false);
-    expect(err2.toString()).toBe(
-      '[404]network error.\ncaused by [404]network error\ncaused by [jsError]Error-original error',
-    );
-  });
-
-  test('type testing', () => {
-    const err0 = new Error('original error');
-    // eslint-disable-next-line no-unused-vars
-    const [err1, value1] = makeErrorBy(NETWORK_CODE, NETWORK_MSG, err0).pair();
-    try {
-      // @ts-expect-error Cannot use value1 without checking error state
-      value1.toString();
-    } catch {
-      // value1 is null, ignore this runtime error
-    }
-
-    if (err1) {
-      // Can directly convert destructured value to ILvErrorOr<string> for easy propagation
-      // eslint-disable-next-line no-unused-vars
-      const err2: ILvErrorOr<string> = err1;
-    }
-    const [err2, value2] = makeOkWith(1).pair();
-    if (!err2) {
-      // State is checked as OK, can directly use value
-      value2.toString();
-    }
-  });
-
-  test('checks if any object is LvErrorRef', () => {
-    expect(isLvErrorRef(makeOk())).toBe(true);
-    expect(isLvErrorRef(makeOkWith(1))).toBe(true);
-    expect(isLvErrorRef(makeError(1, 'hello'))).toBe(true);
-    expect(isLvErrorRef(makeErrorBy(NETWORK_CODE, NETWORK_MSG, makeError(1, 'hello')))).toBe(true);
-    const falsyValues = [
-      undefined,
-      null,
-      true,
-      false,
-      { ok: true, value: 1 },
-      { ok: false },
-      'ok',
-      new Error(),
-    ];
-    falsyValues.forEach((val) => {
-      expect(isLvErrorRef(val)).toBe(false);
-    });
-  });
-
-  test('finds jsError from LvErrorRef if possible', () => {
-    const jsError = new Error('jsError1');
-    const lvError1 = makeErrorBy(-1, 'hello', jsError);
-    expect(lvError1.findJsError()).toBe(jsError);
-
-    const lvError2 = makeErrorBy(-1, 'hello', lvError1);
-    expect(lvError2.findJsError()).toBe(jsError);
-
-    const lvError3 = makeError(-1, 'world');
-    const lvError4 = makeErrorBy(-1, 'hello', lvError3);
-    expect(lvError4.findJsError().message).toBe('[-1]hello.\ncaused by [-1]world');
-  });
-});

package/src/error/error-t.ts

@@ -1,100 +0,0 @@
-import type { ILvErrorRef, ILvErrorOr, ILvRealErrorRef } from './error-base';
-
-//
-// Error类
-//
-// 用户给函数签名明确错误
-// function foo(): ILvErrorRef
-//   return makeOk();  // 如果没有错误
-//   return makeError(code, msg);  // 指定错误码和携带消息
-//
-//   const SomeError = LvErrorConst(code, msg);  // 更推荐用LvErrorConst生成
-//   return SomeError();
-//
-
-const lvErrorRefSymbol = Symbol('lvErrorRef');
-
-function findJsError(error: ILvErrorRef | Error) {
-  let obj: ILvErrorRef | Error | undefined = error;
-  while (obj) {
-    if (obj instanceof Error) {
-      return obj;
-    }
-    obj = (obj as ILvErrorRef).cause;
-  }
-  // 如果没有Error，那就序列化lvError
-  return new Error((error as ILvErrorRef).toString());
-}
-
-export function makeOk<K>(): ILvErrorOr<never, K> {
-  return {
-    ok: true,
-    value: null!,
-    pair() {
-      return [null, null!];
-    },
-    code: 0,
-    msg: '',
-    ...{ [lvErrorRefSymbol]: true }, // 跳过类型检测
-  };
-}
-
-export function makeOkWith<T, K = unknown>(value: T): ILvErrorOr<T, K> {
-  return {
-    ok: true,
-    value,
-    pair() {
-      return [null, value];
-    },
-    code: 0,
-    msg: '',
-    ...{ [lvErrorRefSymbol]: true }, // 跳过类型检测
-  };
-}
-
-function printCause(cause: ILvErrorRef | Error | undefined): string {
-  if (cause === undefined) {
-    return '';
-  } else if (cause instanceof Error) {
-    return `\ncaused by [jsError]${cause.name}-${cause.message}`;
-  } else {
-    return `\ncaused by [${cause.code}]${cause.msg}${cause.ok ? '' : printCause(cause.cause)}`;
-  }
-}
-
-function internalMakeError<T>(code: number, msg: string, cause?: ILvErrorRef | Error, errorInfo?: T) {
-  const errorRef: ILvRealErrorRef<T> = {
-    ok: false,
-    code,
-    msg,
-    cause,
-    errorInfo,
-    toString() {
-      return `[${code}]${msg}.${cause ? printCause(cause) : ''}`;
-    },
-    pair() {
-      return [errorRef, null];
-    },
-    stack: cause instanceof Error ? cause.stack : undefined,
-    findJsError: () => findJsError(errorRef),
-    ...{ [lvErrorRefSymbol]: true }, // 跳过类型检测
-  };
-  return errorRef;
-}
-
-export function makeError<T = unknown>(code: number, msg: string, errorInfo?: T): ILvRealErrorRef<T> {
-  return internalMakeError(code, msg, undefined, errorInfo);
-}
-
-export function makeErrorBy<T = unknown>(
-  code: number,
-  msg: string,
-  cause: ILvErrorRef | Error,
-  errorInfo?: T,
-): ILvRealErrorRef<T> {
-  return internalMakeError(code, msg, cause, errorInfo);
-}
-
-export function isLvErrorRef(val: unknown): val is ILvErrorRef {
-  return typeof val === 'object' && val !== null && lvErrorRefSymbol in val;
-}

package/src/error/index.ts

@@ -1,24 +0,0 @@
-export type { ILvErrorRef } from './error-base';
-export type { ILvRealErrorRef } from './error-base';
-export type { ILvErrorOr } from './error-base';
-
-export { GenericError } from './error-code';
-export { cancelledError } from './error-code';
-export { timeoutError } from './error-code';
-export { permissionDeniedError } from './error-code';
-export { alreadyExistsError } from './error-code';
-export { notSupportedError } from './error-code';
-export { resourceUnavailableError } from './error-code';
-export { outOfRangeError } from './error-code';
-export { invalidArgumentError } from './error-code';
-export { networkFailedError } from './error-code';
-export { interruptedError } from './error-code';
-export { resultNilError } from './error-code';
-
-export { lvErrorConst } from './error-const';
-
-export { makeOk } from './error-t';
-export { makeOkWith } from './error-t';
-export { makeError } from './error-t';
-export { makeErrorBy } from './error-t';
-export { isLvErrorRef } from './error-t';

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

@@ -1 +0,0 @@
-{"version":"1.0.1","results":[[":error-or.test.ts",{"duration":0,"failed":false}],[":error-const.test.ts",{"duration":0,"failed":false}],[":error-t.test.ts",{"duration":1,"failed":false}]]}

package/src/event/disposable-linked-list.ts

@@ -1,29 +0,0 @@
-import { LinkedList } from '@/structure/linked-list';
-
-export class DisposableLinkedList<T> extends LinkedList<T> {
-  unshiftAndGetDisposableNode(value: T): () => void {
-    this.unshift(value);
-
-    const node = this._head!;
-    let hasRemoved = false;
-    return (): void => {
-      if (!hasRemoved) {
-        hasRemoved = true;
-        super._remove(node);
-      }
-    };
-  }
-
-  pushAndGetDisposableNode(value: T): () => void {
-    this.push(value);
-
-    const node = this._tail!;
-    let hasRemoved = false;
-    return (): void => {
-      if (!hasRemoved) {
-        hasRemoved = true;
-        super._remove(node);
-      }
-    };
-  }
-}