@zk-tech/bedrock 0.0.1 → 0.0.2

package/src/di/idle-value.ts

@@ -1,63 +0,0 @@
-import { lvSchedulerCallback, PriorityLevel } from '@/scheduler';
-import type { IDisposable } from '@/dispose';
-import { Emitter, type Event } from '@/event';
-
-//
-// 容器类型，存放一个可以延迟初始化的值
-//
-export class IdleValue<T> implements IDisposable {
-  private readonly _executor: () => void;
-  private readonly _handle: IDisposable;
-  private _executorEmitter?: Emitter<[]>;
-
-  private _didRun = false;
-  private _value?: T;
-  private _error: unknown;
-
-  constructor(executor: () => T) {
-    this._executor = () => {
-      try {
-        this._value = executor();
-      } catch (err) {
-        this._error = err;
-        throw err;
-      } finally {
-        this._didRun = true;
-        if (this._value && this._executorEmitter) {
-          this._executorEmitter.fire();
-        }
-      }
-    };
-    this._handle = lvSchedulerCallback(() => this._executor(), {
-      priorityLevel: PriorityLevel.IdlePriority,
-    });
-  }
-
-  get value(): T {
-    // 如果没有run过，dispose之后再立刻执行
-    if (!this._didRun) {
-      this._handle.dispose();
-      this._executor();
-    }
-    if (this._error) {
-      // eslint-disable-next-line @typescript-eslint/no-throw-literal
-      throw this._error;
-    }
-    return this._value!;
-  }
-
-  get isInitialized(): boolean {
-    return this._didRun;
-  }
-
-  get onExecutor(): Event<[]> {
-    if (!this._executorEmitter) {
-      this._executorEmitter = new Emitter<[]>();
-    }
-    return this._executorEmitter.event;
-  }
-
-  dispose(): void {
-    this._handle.dispose();
-  }
-}

package/src/di/index.common.ts

@@ -1,32 +0,0 @@
-export type { BrandedService } from './base';
-export type { ServiceIdentifier } from './base';
-export type { ServicesAccessor } from './base';
-export { createDecorator } from './base';
-export { refineServiceDecorator } from './base';
-
-export { SyncDescriptor } from './descriptor';
-
-export type { GetLeadingNonServiceArgs } from './instantiation-service.interface';
-export { IInstantiationService } from './instantiation-service.interface';
-export { InstantiationService } from './instantiation-service';
-
-// alias进行历史命名兼容
-export { InstantiationService as ContainerService } from './instantiation-service';
-export { IInstantiationService as IContainerService } from './instantiation-service.interface';
-
-export { getService } from './instantiation-service';
-export { InstantiationErrorType } from './instantiation-service';
-
-export type { IServiceCollection } from './service-collection';
-export { ServiceCollection } from './service-collection';
-
-export { ServiceOwnership } from './service-ownership-collection';
-
-export { ServiceRegistry } from './service-registry';
-
-export type { LazyService } from './lazy/type';
-
-export type { ILazyServiceLoader } from './lazy/lazy-service';
-export { LazyServiceLoader } from './lazy/lazy-service';
-
-export { makeLazyServiceIdleLoad } from './lazy/idle-load';

package/src/di/index.ts

@@ -1,2 +0,0 @@
-export * from './index.common';
-export { InstantiationContext, useService } from './context.web';

package/src/di/instantiation-service.interface.ts

@@ -1,46 +0,0 @@
-import type { BrandedService, ServicesAccessor } from './base';
-import { createDecorator } from './base';
-import type { SyncDescriptor0 } from './descriptor';
-import type { ServiceCollection } from './service-collection';
-
-export type GetLeadingNonServiceArgs<TArgs extends any[]> = TArgs extends []
-  ? []
-  : TArgs extends [...infer TFirst, BrandedService]
-    ? GetLeadingNonServiceArgs<TFirst>
-    : TArgs;
-
-export interface IInstantiationService {
-  readonly _serviceBrand: undefined;
-
-  /**
-   * Synchronously creates an instance that is denoted by the descriptor
-   */
-  createInstance: {
-    <T>(descriptor: SyncDescriptor0<T>): T;
-    <Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(
-      ctor: Ctor,
-      ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>
-    ): R;
-  };
-
-  /**
-   * Calls a function with a service accessor.
-   */
-  invokeFunction: <R, TS extends any[] = []>(
-    fn: (accessor: ServicesAccessor, ...args: TS) => R,
-    ...args: TS
-  ) => R;
-
-  /**
-   * Creates a child of this service which inherits all current services
-   * and adds/overwrites the given services.
-   */
-  createChild: (services: ServiceCollection) => IInstantiationService;
-
-  /**
-   * 生命周期归属该DI上下文的服务进行销毁
-   */
-  dispose: () => void;
-}
-
-export const IInstantiationService = createDecorator<IInstantiationService>('instantiation');

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

@@ -1,337 +0,0 @@
-import { createDecorator } from './base';
-import { SyncDescriptor } from './descriptor';
-import { getService, InstantiationService } from './instantiation-service';
-import { IInstantiationService } from './instantiation-service.interface';
-import { ServiceRegistry } from './service-registry';
-
-let serviceRegistry: ServiceRegistry;
-
-const IA = createDecorator<A>('a');
-const IB = createDecorator<B>('b');
-const IC = createDecorator<C>('c');
-const IX = createDecorator<X>('x');
-const IY = createDecorator<Y>('y');
-
-class Y {
-  _serviceBrand: undefined;
-  name = 'Y';
-}
-
-class X {
-  _serviceBrand: undefined;
-  name = 'X';
-  y: Y;
-
-  constructor(@IY y: Y) {
-    this.y = y;
-  }
-}
-
-class C {
-  _serviceBrand: undefined;
-  name = 'C';
-  x: X;
-
-  constructor(@IX x: X) {
-    this.x = x;
-  }
-}
-
-class B {
-  _serviceBrand: undefined;
-  name = 'B';
-  c: C;
-
-  constructor(@IC c: C) {
-    this.c = c;
-  }
-}
-
-class A {
-  _serviceBrand: undefined;
-  name = 'A';
-  b: B;
-  x: X;
-
-  constructor(@IB b: B, @IX x: X) {
-    this.b = b;
-    this.x = x;
-  }
-}
-
-describe('createInstance fail', () => {
-  beforeEach(() => {
-    serviceRegistry = new ServiceRegistry();
-  });
-
-  // 出现重复创建服务
-  // Bar -> Foo
-  // 当时Foo在创建过程中，动态的创建了Bar
-  it('repeat', () => {
-    const IFoo = createDecorator<Foo>('foo');
-    const IBar = createDecorator<Bar>('bar');
-
-    interface IFoo {
-      _serviceBrand: undefined;
-      name: string;
-    }
-
-    class Bar {
-      _serviceBrand: undefined;
-      name = 'Bar';
-      foo: IFoo;
-
-      constructor(@IFoo foo: IFoo) {
-        this.foo = foo;
-      }
-    }
-    serviceRegistry.register(IBar, Bar);
-
-    class Foo implements IFoo {
-      _serviceBrand: undefined;
-      name = 'Foo';
-      instantiationService: IInstantiationService;
-
-      constructor(@IInstantiationService instantiationService: IInstantiationService) {
-        this.instantiationService = instantiationService;
-        instantiationService.createInstance(Bar);
-      }
-    }
-    serviceRegistry.register(IFoo, Foo);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-
-    expect(() => {
-      instantiationService.createInstance(Bar);
-    }).toThrow(`illegal state - RECURSIVELY instantiating service 'foo'`);
-  });
-
-  // 服务创建过程中出现环
-  // Bar -> Foo -> Bar
-  it('has cyclicDependency', () => {
-    const IFoo = createDecorator<Foo>('foo');
-    const IBar = createDecorator<Bar>('bar');
-
-    interface IFoo {
-      _serviceBrand: undefined;
-      name: string;
-    }
-
-    interface IBar {
-      _serviceBrand: undefined;
-      name: string;
-    }
-
-    class Foo implements IFoo {
-      _serviceBrand: undefined;
-      name = 'Foo';
-      bar: IBar;
-
-      constructor(@IBar bar: IBar) {
-        this.bar = bar;
-      }
-    }
-    serviceRegistry.register(IFoo, Foo);
-
-    class Bar implements IBar {
-      _serviceBrand: undefined;
-      name = 'Bar';
-      foo: IFoo;
-
-      constructor(@IFoo foo: IFoo) {
-        this.foo = foo;
-      }
-    }
-    serviceRegistry.register(IBar, Bar);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    expect(() => {
-      instantiationService.createInstance(Bar);
-    }).toThrow('foo -> bar -> foo');
-  });
-
-  // 依赖的服务没有注册
-  it('service unregister', () => {
-    serviceRegistry.register(IX, X);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    expect(() => {
-      instantiationService.createInstance(X);
-    }).toThrow('[createInstance] X depends on UNKNOWN service y.');
-  });
-});
-
-describe('createInstance success1', () => {
-  beforeEach(() => {
-    serviceRegistry = new ServiceRegistry();
-  });
-
-  // 没有依赖
-  it('no dependency', () => {
-    serviceRegistry.register(IY, Y);
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    let y: undefined | Y;
-    expect(() => {
-      y = instantiationService.createInstance(Y);
-    }).not.toThrow('Cannot register a disposable on itself.');
-    expect(y).not.toBeUndefined();
-    expect(y!.name).toBe('Y');
-  });
-});
-
-describe('createInstance success2', () => {
-  beforeEach(() => {
-    serviceRegistry = new ServiceRegistry();
-  });
-
-  // 存在依赖
-  // X -> Y
-  it('has dependency', () => {
-    serviceRegistry.register(IX, X);
-    serviceRegistry.register(IY, Y);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    let x: undefined | X;
-    expect(() => {
-      x = instantiationService.createInstance(X);
-    }).not.toThrow('Cannot register a disposable on itself.');
-    expect(x).not.toBeUndefined();
-    expect(x!.name).toBe('X');
-    expect(x!.y.name).toBe('Y');
-  });
-
-  // 较为复杂的依赖情况
-  // A -> B -> C -> X -> Y
-  // A -> X -> Y
-  it('has dependency2', () => {
-    serviceRegistry.register(IA, A);
-    serviceRegistry.register(IB, B);
-    serviceRegistry.register(IC, C);
-    serviceRegistry.register(IX, X);
-    serviceRegistry.register(IY, Y);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    let a: undefined | A;
-    expect(() => {
-      a = instantiationService.createInstance(A);
-    }).not.toThrowError();
-    expect(a).not.toBeUndefined();
-    expect(a!.name).toBe('A');
-    expect(a!.b.name).toBe('B');
-    expect(a!.b.c.name).toBe('C');
-    expect(a!.b.c.x.name).toBe('X');
-    expect(a!.b.c.x.y.name).toBe('Y');
-    expect(a!.x.name).toBe('X');
-    expect(a!.x.y.name).toBe('Y');
-  });
-
-  // 底层依赖了上层
-  // J(child) -> B(parent)
-  it('has dependency3', () => {
-    serviceRegistry.register(IY, Y);
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-
-    const IJ = createDecorator<J>('j');
-
-    class J {
-      _serviceBrand: undefined;
-      name = 'J';
-      y: Y;
-
-      constructor(@IY y: Y) {
-        this.y = y;
-      }
-    }
-    const childRegister = new ServiceRegistry();
-    childRegister.register(IJ, J);
-    const childInstantiationService = instantiationService.createChild(childRegister.makeCollection());
-    let j: undefined | J;
-    expect(() => {
-      j = childInstantiationService.createInstance(J);
-    }).not.toThrowError();
-    expect(j).not.toBeUndefined();
-    expect(j!.name).toBe('J');
-    expect(j!.y.name).toBe('Y');
-  });
-});
-
-describe('createInstance success3', () => {
-  beforeEach(() => {
-    serviceRegistry = new ServiceRegistry();
-  });
-
-  // 支持静态参数，动态参数，注入的服务参数
-  it('arguments', () => {
-    class Foo {
-      _serviceBrand: undefined;
-      name = 'Foo';
-    }
-    const IFoo = createDecorator<Foo>('foo');
-    serviceRegistry.register(IFoo, Foo);
-
-    class Bar {
-      _serviceBrand: undefined;
-      name = 'Bar';
-      foo: Foo;
-      a1: number;
-      a2: string;
-
-      constructor(a1: number, a2: string, @IFoo foo: Foo) {
-        this.a1 = a1;
-        this.a2 = a2;
-        this.foo = foo;
-      }
-    }
-    const IBar = createDecorator<Bar>('bar');
-    const descriptor = new SyncDescriptor(Bar, [100]);
-    serviceRegistry.register(IBar, descriptor);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    let bar: undefined | Bar;
-    expect(() => {
-      bar = instantiationService.createInstance(descriptor, '123');
-    }).not.toThrow('Cannot register a disposable on itself.');
-    expect(bar).not.toBeUndefined();
-    expect(bar!.foo.name).toBe('Foo');
-    expect(bar!.a1).toBe(100);
-    expect(bar!.a2).toBe('123');
-  });
-});
-
-describe('get service success', () => {
-  beforeEach(() => {
-    serviceRegistry = new ServiceRegistry();
-  });
-
-  it('get', () => {
-    const IFoo = createDecorator<Foo>('foo');
-    const IBar = createDecorator<Bar>('bar');
-
-    interface IFoo {
-      _serviceBrand: undefined;
-      name: string;
-    }
-
-    class Bar {
-      _serviceBrand: undefined;
-      name = 'Bar';
-      foo: IFoo;
-
-      constructor(@IFoo foo: IFoo) {
-        this.foo = foo;
-      }
-    }
-    serviceRegistry.register(IBar, Bar);
-
-    class Foo implements IFoo {
-      _serviceBrand: undefined;
-      name = 'Foo';
-    }
-    const foo = new Foo();
-    serviceRegistry.registerInstance(IFoo, foo);
-
-    const instantiationService = new InstantiationService(serviceRegistry.makeCollection());
-    expect(getService(instantiationService, IBar)).not.toBeUndefined();
-    expect(getService(instantiationService, IFoo)).toBe(foo);
-  });
-});