@zk-tech/bedrock 0.0.1

package/dist/di/index.d.ts

@@ -0,0 +1,140 @@
+import { I as IInstantiationService, S as ServiceCollection, a as ServicesAccessor, b as SyncDescriptor0, G as GetLeadingNonServiceArgs, c as SyncDescriptor, d as ServiceIdentifier, B as BrandedService, e as ServiceOwnershipCollection, f as ServiceOwnership } from '../instantiation-service.interface-CVFMBUUD.js';
+export { h as IServiceCollection, g as createDecorator, r as refineServiceDecorator } from '../instantiation-service.interface-CVFMBUUD.js';
+import { G as Graph } from '../graph-BGbNOniY.js';
+import { E as Event } from '../emitter-DeM5mlEm.js';
+import { ReactElement } from 'react';
+import '../dispose-base-CAeXDpjg.js';
+import '../linked-list-CUkue5DZ.js';
+
+type DepGraph = Graph<string, any>;
+declare enum InstantiationErrorType {
+    UnknownDependency = "UnknownDependency"
+}
+interface IBaseErrorEvent {
+    errorType: InstantiationErrorType;
+    message: string;
+}
+interface IUnknownDependencyErrorEvent extends IBaseErrorEvent {
+    errorType: InstantiationErrorType.UnknownDependency;
+    dependencyId: string;
+    issuer: string;
+}
+type ErrorDataType = IUnknownDependencyErrorEvent;
+/**
+ * 从容器中获取对应的service
+ * @param instantiationService
+ * @param id
+ * @returns Service<T>
+ *
+ * @remarks 减少使用该方法，尽量将业务函数作为invokeFunction的参数，从accessor中获取你所期望的service
+ */
+declare function getService<T>(instantiationService: IInstantiationService, id: ServiceIdentifier<T>): T;
+declare class InstantiationService implements IInstantiationService {
+    readonly _serviceBrand: undefined;
+    readonly _globalGraph?: DepGraph;
+    private readonly _services;
+    private readonly _parent?;
+    private readonly _childs;
+    private readonly _enableTracing;
+    private _globalGraphImplicitDependency?;
+    private readonly _activeInstantiations;
+    private _emitter;
+    constructor(services?: ServiceCollection, parent?: InstantiationService, enableTracing?: boolean);
+    get services(): ServiceCollection;
+    get onError(): Event<[ErrorDataType]>;
+    createChild(services: ServiceCollection): IInstantiationService;
+    invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;
+    createInstance<T>(descriptor: SyncDescriptor0<T>): T;
+    createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+    createInstance<T, Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(descriptor: SyncDescriptor<T>, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+    dispose(): void;
+    private _createInstance;
+    private _setServiceInstance;
+    private _getServiceInstanceOrDescriptor;
+    private _getOrCreateServiceInstance;
+    private _safeCreateAndCacheServiceInstance;
+    private _createAndCacheServiceInstance;
+    private _createServiceInstanceWithOwner;
+    private _createServiceInstance;
+    private _createService;
+    private _handleError;
+}
+
+declare enum InstantiationType {
+    Eager = 0,
+    Delayed = 1
+}
+interface IServiceRegistryConfig {
+    checkDuplicate?: boolean;
+}
+declare class ServiceRegistry {
+    protected readonly _registry: [ServiceIdentifier<any>, SyncDescriptor<any> | BrandedService][];
+    protected readonly _serviceOwnership: ServiceOwnershipCollection;
+    private readonly _ids;
+    private readonly _checkDuplicate;
+    constructor(config?: IServiceRegistryConfig);
+    get registry(): [ServiceIdentifier<any>, BrandedService | SyncDescriptor<any>][];
+    /**
+     * 注册服务，通过传入构造函数或者描述符
+     */
+    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
+     * 一般用于特殊场景：需要先于DI之前就构造了某个service
+     */
+    registerInstance<T extends BrandedService>(id: ServiceIdentifier<T>, instance: T, options?: {
+        ownership: ServiceOwnership;
+    }): void;
+    makeCollection(): ServiceCollection;
+}
+
+type LazyService<T> = {
+    readonly _serviceBrand: undefined;
+    getInstance: () => Promise<T>;
+};
+
+interface ILazyServiceLoader<T> {
+    readonly _serviceBrand: undefined;
+    getInstance: (...rest: any[]) => Promise<T>;
+    loaded: boolean;
+    preload: () => void;
+}
+type ILoaderResult<T> = {
+    default: new (...args: any[]) => T;
+};
+type ILoaderResult0<T> = new (...args: any[]) => T;
+declare abstract class LazyServiceLoader<T extends BrandedService> implements ILazyServiceLoader<T> {
+    protected readonly _instantiationService: IInstantiationService;
+    readonly _serviceBrand: undefined;
+    protected _instance?: T;
+    private readonly _sharedMutex;
+    constructor(_instantiationService: IInstantiationService);
+    get loaded(): boolean;
+    preload(): void;
+    getInstance(): Promise<T>;
+    protected _makeInstance(...rest: any[]): Promise<T>;
+    protected abstract _getModule(): Promise<ILoaderResult<T> | ILoaderResult0<T>>;
+    protected _getStaticArguments(): any[];
+}
+
+declare function makeLazyServiceIdleLoad<T extends BrandedService>(ctor: new (..._args: any[]) => ILazyServiceLoader<T>, staticArguments?: any[]): SyncDescriptor<ILazyServiceLoader<T>>;
+
+interface IProps {
+    instantiationService: IInstantiationService;
+    children?: React.ReactNode;
+}
+/**
+ * 组件支持依赖注入上下文
+ */
+declare const InstantiationContext: (props: IProps) => ReactElement<any, any>;
+/**
+ * 获取服务的hook
+ * @param identifier 服务标识符
+ * @returns 对应服务
+ */
+declare function useService<T>(identifier: ServiceIdentifier<T>): T;
+
+export { BrandedService, InstantiationService as ContainerService, GetLeadingNonServiceArgs, IInstantiationService as IContainerService, IInstantiationService, type ILazyServiceLoader, InstantiationContext, InstantiationErrorType, InstantiationService, type LazyService, LazyServiceLoader, ServiceCollection, ServiceIdentifier, ServiceOwnership, ServiceRegistry, ServicesAccessor, SyncDescriptor, getService, makeLazyServiceIdleLoad, useService };