@zk-tech/bedrock 0.0.1 → 0.1.0

package/src/di/proxy-builder.test.ts

@@ -1,45 +0,0 @@
-import { makeProxy } from './proxy-builder';
-import { IdleValue } from './idle-value';
-
-vi.useFakeTimers();
-vi.spyOn(global, 'setTimeout');
-vi.spyOn(global, 'clearTimeout');
-
-class Foo {
-  private _data = 100;
-  private readonly _mockFn: () => void;
-  value = 'public value.';
-
-  constructor(mockFn: () => void) {
-    this._mockFn = mockFn;
-  }
-
-  get data() {
-    return this._data;
-  }
-
-  set data(value: number) {
-    this._data = value;
-  }
-
-  test() {
-    this._mockFn();
-  }
-}
-
-describe('proxy builder', () => {
-  it('proxy success', () => {
-    const fn = vi.fn();
-    const wrapper = new IdleValue<Foo>(() => new Foo(fn));
-    const proxy = makeProxy<Foo>(wrapper, Foo);
-    // 属性正常
-    expect(proxy.value).toBe('public value.');
-    // setter/getter 正常
-    expect(proxy.data).toBe(100);
-    proxy.data = 200;
-    expect(proxy.data).toBe(200);
-    // 调用方法正常
-    proxy.test();
-    expect(fn).toBeCalled();
-  });
-});

package/src/di/proxy-builder.ts

@@ -1,38 +0,0 @@
-import { listenOnce } from '@/event';
-import type { IdleValue } from './idle-value';
-
-//
-// 快速生成一个di proxy对象，用于di中的延迟初始化能力
-// 依赖idleValue容器
-//
-export function makeProxy<T>(valueWrapper: IdleValue<T>, ctor: any) {
-  const wrapper = Object.create(null);
-  const result =  new Proxy(wrapper, {
-    get(target: any, key: PropertyKey): any {
-      if (key in target) {
-        return target[key];
-      }
-
-      const obj = valueWrapper.value as any;
-      let prop = obj[key];
-      if (typeof prop !== 'function') {
-        return prop;
-      }
-      prop = prop.bind(obj);
-      target[key] = prop;
-      return prop;
-    },
-    set(_target: T, p: PropertyKey, value: any): boolean {
-      const obj = valueWrapper.value as any;
-      obj[p] = value;
-      return true;
-    },
-  }) as T;
-  // @ts-ignore
-  wrapper.__originClass__ = ctor;
-  listenOnce(valueWrapper.onExecutor)(() => {
-    // @ts-ignore
-    wrapper.__origin__ = valueWrapper.value;
-  });
-  return result as T;
-}

package/src/di/service-collection.test.ts

@@ -1,27 +0,0 @@
-import { createDecorator } from './base';
-import { SyncDescriptor } from './descriptor';
-import { ServiceCollection } from './service-collection';
-
-class Foo {}
-class Bar {}
-
-const IFoo = createDecorator<Foo>('foo');
-const IBar = createDecorator<Bar>('bar');
-
-describe('service collection', () => {
-  it('success', () => {
-    const collection = new ServiceCollection();
-    expect(collection.has(IFoo)).toBe(false);
-    // 设置SyncDescriptor
-    const descriptor = new SyncDescriptor<Foo>(Foo);
-    collection.set(IFoo, descriptor);
-    expect(collection.has(IFoo)).toBe(true);
-    expect(collection.get(IFoo)).toBe(descriptor);
-
-    expect(collection.has(IBar)).toBe(false);
-    // 设置instance
-    const bar = new Bar();
-    collection.set(IBar, bar);
-    expect(collection.has(IBar)).toBe(true);
-  });
-});

package/src/di/service-collection.ts

@@ -1,46 +0,0 @@
-import type { ServiceIdentifier } from './base';
-import { SyncDescriptor } from './descriptor';
-import { ServiceOwnershipCollection } from './service-ownership-collection';
-//
-// 服务的集合
-// key 服务ID
-// value 服务的描述符或者是实例
-//
-export type IServiceCollection = {
-  entries?: [ServiceIdentifier<any>, any][];
-  ownership?: ServiceOwnershipCollection;
-};
-
-export class ServiceCollection {
-  private readonly _entries = new Map<ServiceIdentifier<any>, any>();
-  private readonly _ownership: ServiceOwnershipCollection | undefined;
-
-  constructor(options?: IServiceCollection) {
-    for (const [id, service] of options?.entries || []) {
-      this.set(id, service);
-    }
-    if (options?.ownership) {
-      this._ownership = options.ownership;
-    }
-  }
-
-  get entries() {
-    return this._entries;
-  }
-
-  get ownerships() {
-    return this._ownership?.entries;
-  }
-
-  set<T>(id: ServiceIdentifier<T>, instanceOrDescriptor: T | SyncDescriptor<T>) {
-    this._entries.set(id, instanceOrDescriptor);
-  }
-
-  has(id: ServiceIdentifier<any>): boolean {
-    return this._entries.has(id);
-  }
-
-  get<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
-    return this._entries.get(id);
-  }
-}

package/src/di/service-ownership-collection.test.ts

@@ -1,39 +0,0 @@
-import { createDecorator } from './base';
-import { ServiceOwnershipCollection, ServiceOwnership } from './service-ownership-collection';
-
-class Foo {}
-class Bar {}
-
-const IFoo = createDecorator<Foo>('foo');
-const IBar = createDecorator<Bar>('bar');
-
-describe('service collection', () => {
-  it('success', () => {
-    const collection = new ServiceOwnershipCollection();
-    expect(collection.has(IFoo)).toBe(false);
-
-    collection.set(IFoo, ServiceOwnership.Owned);
-    expect(collection.has(IFoo)).toBe(true);
-    expect(collection.get(IFoo)).toBe(ServiceOwnership.Owned);
-
-    collection.set(IFoo, ServiceOwnership.Reference);
-    expect(collection.get(IFoo)).toBe(ServiceOwnership.Reference);
-  });
-
-  it('base', () => {
-    const collection = new ServiceOwnershipCollection(
-      [IFoo, ServiceOwnership.Owned],
-      [IBar, ServiceOwnership.Reference],
-    );
-
-    expect(collection.has(IFoo)).toBe(true);
-    expect(collection.has(IBar)).toBe(true);
-    expect(collection.get(IFoo)).toBe(ServiceOwnership.Owned);
-    expect(collection.get(IBar)).toBe(ServiceOwnership.Reference);
-
-    const ownership = collection.entries;
-    expect(ownership.size).toBe(2);
-    expect(ownership.get(IFoo)).toBe(ServiceOwnership.Owned);
-    expect(ownership.get(IBar)).toBe(ServiceOwnership.Reference);
-  });
-});

package/src/di/service-ownership-collection.ts

@@ -1,38 +0,0 @@
-import type { ServiceIdentifier } from './base';
-
-export enum ServiceOwnership {
-  Owned = 1, // 单独持有
-  Reference = 2, // 引用子父级类型
-  // Shared = 3, // 与兄弟节点共同持有
-}
-
-//
-// 服务的集合
-// key 服务ID
-// value 服务的描述符或者是实例
-//
-export class ServiceOwnershipCollection {
-  private readonly _entries = new Map<ServiceIdentifier<any>, ServiceOwnership>();
-
-  constructor(...entries: [ServiceIdentifier<any>, ServiceOwnership][]) {
-    for (const [id, service] of entries) {
-      this.set(id, service);
-    }
-  }
-
-  get entries() {
-    return this._entries;
-  }
-
-  set(id: ServiceIdentifier<any>, ownership: ServiceOwnership) {
-    this._entries.set(id, ownership);
-  }
-
-  has(id: ServiceIdentifier<any>): boolean {
-    return this._entries.has(id);
-  }
-
-  get(id: ServiceIdentifier<any>): ServiceOwnership | undefined {
-    return this._entries.get(id);
-  }
-}

package/src/di/service-registry.test.ts

@@ -1,66 +0,0 @@
-import { createDecorator } from './base';
-import { SyncDescriptor } from './descriptor';
-import { ServiceOwnership } from './service-ownership-collection';
-import { InstantiationType, ServiceRegistry } from './service-registry';
-
-class Foo {
-  _serviceBrand: undefined;
-}
-class Bar {
-  _serviceBrand: undefined;
-  option1: number;
-  option2: string;
-
-  constructor(option1: number, option2: string) {
-    this.option1 = option1;
-    this.option2 = option2;
-  }
-}
-
-class Test {
-  _serviceBrand: undefined;
-}
-
-class ReferenceTest {
-  _serviceBrand: undefined;
-}
-
-const IFoo = createDecorator<Foo>('foo');
-const IBar = createDecorator<Bar>('bar');
-const ITest = createDecorator<Test>('test');
-const IReferenceTest = createDecorator<ReferenceTest>('reference-test');
-
-describe('registry', () => {
-  it('register success', () => {
-    const serviceRegistry = new ServiceRegistry();
-    serviceRegistry.register(IFoo, Foo, InstantiationType.Eager);
-    serviceRegistry.register(IBar, new SyncDescriptor(Bar, [100, 'Hello'], true));
-    serviceRegistry.registerInstance(ITest, new Test());
-
-    expect(serviceRegistry.registry.length).toBe(3);
-
-    expect(serviceRegistry.registry[0][0]).toBe(IFoo);
-    expect(serviceRegistry.registry[0][1] instanceof SyncDescriptor).toBeTruthy();
-    expect((serviceRegistry.registry[0][1] as SyncDescriptor<Foo>).ctor).toBe(Foo);
-    expect((serviceRegistry.registry[0][1] as SyncDescriptor<Foo>).staticArguments.length).toBe(0);
-    expect((serviceRegistry.registry[0][1] as SyncDescriptor<Foo>).supportsDelayedInstantiation).toBe(false);
-
-    expect(serviceRegistry.registry[1][0]).toBe(IBar);
-    expect(serviceRegistry.registry[1][1] instanceof SyncDescriptor).toBeTruthy();
-    expect((serviceRegistry.registry[1][1] as SyncDescriptor<Bar>).ctor).toBe(Bar);
-    expect((serviceRegistry.registry[1][1] as SyncDescriptor<Bar>).staticArguments.length).toBe(2);
-    expect((serviceRegistry.registry[1][1] as SyncDescriptor<Bar>).staticArguments[0]).toBe(100);
-    expect((serviceRegistry.registry[1][1] as SyncDescriptor<Bar>).staticArguments[1]).toBe('Hello');
-    expect((serviceRegistry.registry[1][1] as SyncDescriptor<Bar>).supportsDelayedInstantiation).toBe(true);
-
-    expect(serviceRegistry.registry[2][0]).toBe(ITest);
-    expect(serviceRegistry.registry[2][1] instanceof Test).toBeTruthy();
-    expect(serviceRegistry.makeCollection().ownerships!.get(ITest)).toBe(ServiceOwnership.Owned);
-
-    serviceRegistry.registerInstance(IReferenceTest, new ReferenceTest(), {
-      ownership: ServiceOwnership.Reference,
-    });
-    expect(serviceRegistry.registry[3][0]).toBe(IReferenceTest);
-    expect(serviceRegistry.makeCollection().ownerships!.get(IReferenceTest)).toBe(ServiceOwnership.Reference);
-  });
-});

package/src/di/service-registry.ts

@@ -1,99 +0,0 @@
-import { lvAssert } from '../assert';
-import type { BrandedService, ServiceIdentifier } from './base';
-import { SyncDescriptor } from './descriptor';
-import { ServiceCollection } from './service-collection';
-import { ServiceOwnershipCollection, ServiceOwnership } from './service-ownership-collection';
-
-export enum InstantiationType {
-  Eager = 0,
-  Delayed = 1,
-}
-
-interface IServiceRegistryConfig {
-  checkDuplicate?: boolean;
-}
-
-export class ServiceRegistry {
-  protected readonly _registry: [ServiceIdentifier<any>, SyncDescriptor<any> | BrandedService][] = [];
-  protected readonly _serviceOwnership: ServiceOwnershipCollection = new ServiceOwnershipCollection();
-  // 重复检测的id记录
-  private readonly _ids: Set<string> = new Set<string>();
-  // 是否进行相同id服务注册的冲突检测
-  private readonly _checkDuplicate: boolean;
-
-  constructor(config: IServiceRegistryConfig = {}) {
-    this._checkDuplicate = config.checkDuplicate ?? false;
-  }
-
-  get registry() {
-    return this._registry;
-  }
-
-  /**
-   * 注册服务，通过传入构造函数或者描述符
-   */
-  register<T, Services extends BrandedService[]>(
-    id: ServiceIdentifier<T>,
-    ctor: new (...services: Services) => T,
-    supportsDelayedInstantiation?: boolean | InstantiationType,
-  ): void;
-  register<T, Services extends BrandedService[]>(
-    id: ServiceIdentifier<T>,
-    descriptor: SyncDescriptor<any>,
-  ): void;
-  register<T, Services extends BrandedService[]>(
-    id: ServiceIdentifier<T>,
-    ctorOrDescriptor: { new (...services: Services): T } | SyncDescriptor<any>,
-    supportsDelayedInstantiation?: boolean | InstantiationType,
-  ) {
-    // 无论是构造函数还是描述符，最终加入到registry中的都会转为描述符
-    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
-      ctorOrDescriptor = new SyncDescriptor<T>(
-        ctorOrDescriptor as new (...args: any[]) => T,
-        [],
-        Boolean(supportsDelayedInstantiation),
-      );
-    }
-
-    // 如果开启了检测，判断是否有id重复
-    if (this._checkDuplicate) {
-      lvAssert(!this._ids.has(id.toString()), `service: ${id.toString()} duplicate register.`);
-      this._ids.add(id.toString());
-    }
-
-    this._registry.push([id, ctorOrDescriptor]);
-  }
-
-  /**
-   * 直接注册一个服务的实例
-   *
-   * 注意：谨慎使用，优先使用register
-   * 一般用于特殊场景：需要先于DI之前就构造了某个service
-   */
-  registerInstance<T extends BrandedService>(
-    id: ServiceIdentifier<T>,
-    instance: T,
-    options?: {
-      ownership: ServiceOwnership;
-    },
-  ) {
-    // 如果开启了检测，判断是否有id重复
-    if (this._checkDuplicate) {
-      lvAssert(!this._ids.has(id.toString()), `service: ${id.toString()} duplicate register.`);
-      this._ids.add(id.toString());
-    }
-
-    this._registry.push([id, instance]);
-    this._serviceOwnership.set(id, options?.ownership ?? ServiceOwnership.Owned);
-  }
-
-  makeCollection(): ServiceCollection {
-    const serviceCollection = new ServiceCollection({
-      ownership: this._serviceOwnership,
-    });
-    for (const [id, instanceOrDescriptor] of this.registry) {
-      serviceCollection.set(id, instanceOrDescriptor);
-    }
-    return serviceCollection;
-  }
-}

package/src/di/trace.ts

@@ -1,85 +0,0 @@
-import type { ServiceIdentifier } from './base';
-
-enum TraceType {
-  None = 0,
-  Creation = 1,
-  Invocation = 2,
-  Branch = 3,
-}
-
-export class Trace {
-  static all = new Set<string>();
-
-  private static readonly _None = new (class extends Trace {
-    constructor() {
-      super(TraceType.None, null);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    override stop() {}
-    override branch() {
-      return this;
-    }
-  })();
-
-  static traceInvocation(_enableTracing: boolean, ctor: any): Trace {
-    return !_enableTracing
-      ? Trace._None
-      : new Trace(TraceType.Invocation, ctor.name || new Error().stack!.split('\n').slice(3, 4).join('\n'));
-  }
-
-  static traceCreation(_enableTracing: boolean, ctor: any): Trace {
-    return !_enableTracing ? Trace._None : new Trace(TraceType.Creation, ctor.name);
-  }
-
-  private static _totals = 0;
-  private readonly _start: number = Date.now();
-  private readonly _dep: [ServiceIdentifier<any>, boolean, Trace?][] = [];
-  private readonly _type: TraceType;
-  private readonly _name: string | null;
-
-  private constructor(type: TraceType, name: string | null) {
-    this._type = type;
-    this._name = name;
-  }
-
-  branch(id: ServiceIdentifier<any>, first: boolean): Trace {
-    const child = new Trace(TraceType.Branch, id.toString());
-    this._dep.push([id, first, child]);
-    return child;
-  }
-
-  stop() {
-    const dur = Date.now() - this._start;
-    Trace._totals += dur;
-
-    let causedCreation = false;
-
-    function printChild(n: number, trace: Trace) {
-      const res: string[] = [];
-      const prefix = new Array(n + 1).join('\t');
-      for (const [id, first, child] of trace._dep) {
-        if (first && child) {
-          causedCreation = true;
-          res.push(`${prefix}CREATES -> ${id}`);
-          const nested = printChild(n + 1, child);
-          if (nested) {
-            res.push(nested);
-          }
-        } else {
-          res.push(`${prefix}uses -> ${id}`);
-        }
-      }
-      return res.join('\n');
-    }
-
-    const lines = [
-      `${this._type === TraceType.Creation ? 'CREATE' : 'CALL'} ${this._name}`,
-      `${printChild(1, this)}`,
-      `DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`,
-    ];
-
-    if (dur > 2 || causedCreation) {
-      Trace.all.add(lines.join('\n'));
-    }
-  }
-}

package/src/dispose/disposable-store.test.ts

@@ -1,57 +0,0 @@
-import { DisposableStore } from './disposable-store';
-import { Disposable } from './disposable-t';
-
-class Foo extends Disposable {
-  private readonly _mockFunc: () => void;
-
-  constructor(mockFunc: () => void) {
-    super();
-    this._mockFunc = mockFunc;
-  }
-
-  dispose() {
-    this._mockFunc();
-    super.dispose();
-  }
-}
-
-describe('dispose store', () => {
-  it('dispose success', () => {
-    const mockDispose1 = vi.fn();
-    const mockDispose2 = vi.fn();
-
-    const instance = new DisposableStore();
-    expect(instance.isDisposed).toBe(false);
-
-    instance.add(new Foo(mockDispose1));
-    instance.add(new Foo(mockDispose2));
-    instance.dispose();
-
-    expect(mockDispose1).toBeCalled();
-    expect(mockDispose2).toBeCalled();
-    expect(instance.isDisposed).toBe(true);
-  });
-
-  it('clear success', () => {
-    const mockDispose1 = vi.fn();
-    const mockDispose2 = vi.fn();
-
-    const instance = new DisposableStore();
-    expect(instance.isDisposed).toBe(false);
-
-    instance.add(new Foo(mockDispose1));
-    instance.add(new Foo(mockDispose2));
-    instance.clear();
-
-    expect(mockDispose1).toBeCalled();
-    expect(mockDispose2).toBeCalled();
-    expect(instance.isDisposed).toBe(false);
-  });
-
-  it('add self error', () => {
-    const instance = new DisposableStore();
-    expect(() => {
-      instance.add(instance);
-    }).toThrow('Cannot register a disposable on itself.');
-  });
-});

package/src/dispose/disposable-store.ts

@@ -1,80 +0,0 @@
-import { Logger } from '@/_internal/logger';
-import type { IDisposable } from './dispose-base';
-import { BRANCH_DISPOSE } from './logger';
-import { MARK_AS_DISPOSED, SET_PARENT_OF_DISPOSABLE, TRACK_DISPOSABLE } from './tracker';
-
-export class DisposableStore implements IDisposable {
-  static DISABLE_DISPOSED_WARNING = false;
-
-  private readonly _toDispose = new Set<IDisposable>();
-  private _isDisposed = false;
-
-  constructor() {
-    TRACK_DISPOSABLE(this);
-  }
-
-  get isDisposed(): boolean {
-    return this._isDisposed;
-  }
-
-  dispose(): void {
-    if (this._isDisposed) {
-      // 不应该出现重复dispose
-      Logger.warn(new Error('DisposableStore has disposed.').stack);
-      return;
-    }
-
-    MARK_AS_DISPOSED(this);
-    this._isDisposed = true;
-    this.clear();
-  }
-
-  clear(): void {
-    if (this._toDispose.size === 0) {
-      return;
-    }
-
-    for (const disposable of this._toDispose) {
-      BRANCH_DISPOSE(this.constructor.name, disposable.constructor.name);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const errors: any[] = [];
-    for (const disposable of this._toDispose) {
-      try {
-        disposable.dispose();
-      } catch (e) {
-        errors.push(e);
-      }
-    }
-
-    this._toDispose.clear();
-    if (errors.length > 0) {
-      throw new AggregateError(errors, 'find error when dispose store.');
-    }
-  }
-
-  add<T extends IDisposable>(o: T): T {
-    if (!o) {
-      return o;
-    }
-    if ((o as unknown as DisposableStore) === this) {
-      throw new Error('Cannot register a disposable on itself.');
-    }
-
-    SET_PARENT_OF_DISPOSABLE(o, this);
-    if (this._isDisposed) {
-      if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
-        Logger.warn(
-          new Error(
-            'Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!',
-          ).stack,
-        );
-      }
-    } else {
-      this._toDispose.add(o);
-    }
-
-    return o;
-  }
-}