@eggjs/tegg-metadata 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/index.d.ts

@@ -1,23 +1,407 @@
-import { EggPrototypeFactory } from "./factory/EggPrototypeFactory.js";
-import { ProtoSelectorContext } from "./model/graph/ProtoSelector.js";
-import { ProtoDependencyMeta, ProtoNode } from "./model/graph/ProtoNode.js";
-import { GlobalModuleNode, GlobalModuleNodeOptions, ModuleDependencyMeta } from "./model/graph/GlobalModuleNode.js";
-import { ModuleDescriptor, ModuleDescriptorDumper, ModuleDumpOptions } from "./model/ModuleDescriptor.js";
-import { GlobalGraph, GlobalGraphBuildHook, GlobalGraphOptions } from "./model/graph/GlobalGraph.js";
-import { GlobalModuleNodeBuilder } from "./model/graph/GlobalModuleNodeBuilder.js";
-import { AbstractProtoDescriptor, AbstractProtoDescriptorOptions } from "./model/ProtoDescriptor/AbstractProtoDescriptor.js";
-import { ClassProtoDescriptor, ClassProtoDescriptorOptions } from "./model/ProtoDescriptor/ClassProtoDescriptor.js";
-import { AppGraph, ClazzMap, ClazzMetaMap, InstanceClazzMeta, ModuleNode } from "./model/AppGraph.js";
-import { EggPrototypeLifecycleUtil } from "./model/EggPrototype.js";
-import { LoadUnitLifecycleUtil } from "./model/LoadUnit.js";
-import { ProtoDescriptorHelper } from "./model/ProtoDescriptorHelper.js";
-import { EggPrototypeCreatorFactory } from "./factory/EggPrototypeCreatorFactory.js";
-import { LoadUnitFactory } from "./factory/LoadUnitFactory.js";
-import { EggPrototypeNotFound, IncompatibleProtoInject, MultiPrototypeFound, TeggError } from "./errors.js";
-import { ClassUtil } from "./util/ClassUtil.js";
-import { EggPrototypeBuilder } from "./impl/EggPrototypeBuilder.js";
-import { EggPrototypeImpl } from "./impl/EggPrototypeImpl.js";
-import { LoadUnitMultiInstanceProtoHook } from "./impl/LoadUnitMultiInstanceProtoHook.js";
-import { ModuleGraph, ModuleLoadUnit } from "./impl/ModuleLoadUnit.js";
+import { EdgeMeta, Graph, GraphNode, GraphNodeObj, ModuleReference } from "@eggjs/tegg-common-util";
+import { AccessLevel, EggLoadUnitType, EggLoadUnitTypeLike, EggProtoImplClass, EggPrototype, EggPrototypeCreator, EggPrototypeLifecycleContext, EggPrototypeName, GraphNodeObj as GraphNodeObj$1, Id, InjectConstructorProto, InjectObjectDescriptor, InjectObjectProto, LifecycleHook, LoadUnit, LoadUnitCreator, LoadUnitLifecycleContext, Loader, MetaDataKey, ModuleReference as ModuleReference$1, MultiInstancePrototypeGetObjectsContext, ObjectInitTypeLike, ProtoDescriptor, ProtoDescriptorTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg-types";
+import { FrameworkBaseError } from "egg-errors";
+import { InjectType, QualifierAttribute } from "@eggjs/core-decorator";
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
 export * from "@eggjs/tegg-types/metadata";
+
+//#region src/factory/EggPrototypeFactory.d.ts
+declare class EggPrototypeFactory {
+  static instance: EggPrototypeFactory;
+  private publicProtoMap;
+  registerPrototype(proto: EggPrototype, loadUnit: LoadUnit): void;
+  deletePrototype(proto: EggPrototype, loadUnit: LoadUnit): void;
+  getPrototype(name: PropertyKey, loadUnit?: LoadUnit, qualifiers?: QualifierInfo[]): EggPrototype;
+  private doGetPrototype;
+}
+//#endregion
+//#region src/model/graph/ProtoSelector.d.ts
+interface ProtoSelectorContext {
+  name: PropertyKey;
+  qualifiers: QualifierInfo[];
+  moduleName: string;
+}
+//#endregion
+//#region src/model/graph/ProtoNode.d.ts
+declare class ProtoDependencyMeta implements EdgeMeta {
+  injectObj: PropertyKey;
+  constructor({
+    injectObj
+  }: {
+    injectObj: PropertyKey;
+  });
+  equal(meta: ProtoDependencyMeta): boolean;
+  toString(): string;
+}
+declare class ProtoNode implements GraphNodeObj$1 {
+  readonly id: string;
+  readonly proto: ProtoDescriptor;
+  constructor(proto: ProtoDescriptor);
+  toString(): string;
+  selectProto(ctx: ProtoSelectorContext): boolean;
+  static createProtoId(proto: ProtoDescriptor): string;
+}
+//#endregion
+//#region src/model/graph/GlobalModuleNode.d.ts
+interface GlobalModuleNodeOptions {
+  name: string;
+  unitPath: string;
+  optional: boolean;
+}
+declare class ModuleDependencyMeta implements EdgeMeta {
+  readonly obj: ProtoDescriptor;
+  readonly injectObj: PropertyKey;
+  constructor(obj: ProtoDescriptor, injectObj: PropertyKey);
+  equal(meta: ModuleDependencyMeta): boolean;
+  toString(): string;
+}
+declare class GlobalModuleNode implements GraphNodeObj {
+  readonly id: string;
+  readonly name: string;
+  readonly unitPath: string;
+  readonly optional: boolean;
+  readonly protos: GraphNode<ProtoNode, ProtoDependencyMeta>[];
+  constructor(options: GlobalModuleNodeOptions);
+  addProto(proto: ProtoDescriptor): void;
+  toString(): string;
+}
+//#endregion
+//#region src/model/ModuleDescriptor.d.ts
+interface ModuleDescriptor {
+  name: string;
+  unitPath: string;
+  optional?: boolean;
+  clazzList: EggProtoImplClass[];
+  multiInstanceClazzList: EggProtoImplClass[];
+  protos: ProtoDescriptor[];
+}
+interface ModuleDumpOptions {
+  dumpDir?: string;
+}
+declare class ModuleDescriptorDumper {
+  static stringifyDescriptor(moduleDescriptor: ModuleDescriptor): string;
+  static stringifyClazz(clazz: EggProtoImplClass, moduleDescriptor: ModuleDescriptor): string;
+  static dumpPath(desc: ModuleDescriptor, options?: ModuleDumpOptions): string;
+  static dump(desc: ModuleDescriptor, options?: ModuleDumpOptions): Promise<void>;
+}
+//#endregion
+//#region src/model/graph/GlobalGraph.d.ts
+interface GlobalGraphOptions {
+  strict?: boolean;
+}
+type GlobalGraphBuildHook = (globalGraph: GlobalGraph) => void;
+/**
+ * Sort all prototypes and modules in app.
+ * - 1. LoaderFactory.loadApp: get ModuleDescriptors
+ * - 2. GlobalGraph.create: create global graph instance
+ * - 3. graph.build:
+ *   - check duplicated prototypes exits
+ *   - check inject object exists (only in strict mode,
+ *   can register proto in hooks now, in next major version,
+ *   should use load to create dynamic ProtoDescriptor and delete
+ *   strict false options
+ *   )
+ * - 4. graph.sort: build moduleConfigList and moduleProtoDescriptorMap
+ */
+declare class GlobalGraph {
+  #private;
+  /**
+   * Vertex: ModuleNode, collect prototypes in module
+   * Edge: ModuleDependencyMeta, prototype and it's inject object
+   * @private
+   */
+  moduleGraph: Graph<GlobalModuleNode, ModuleDependencyMeta>;
+  /**
+   * Vertex: ProtoNode, collect all prototypes in app
+   * Edge: ProtoDependencyMeta, inject object
+   * @private
+   */
+  protoGraph: Graph<ProtoNode, ProtoDependencyMeta>;
+  /**
+   * The order of the moduleConfigList is the order in which they are instantiated
+   */
+  moduleConfigList: readonly ModuleReference[];
+  /**
+   * key: module name
+   * value: ProtoDescriptor in module, the order is the order in which they are instantiated
+   */
+  moduleProtoDescriptorMap: Map<string, ProtoDescriptor[]>;
+  strict: boolean;
+  private buildHooks;
+  /**
+   * The global instance used in ModuleLoadUnit
+   */
+  static instance?: GlobalGraph;
+  constructor(options?: GlobalGraphOptions);
+  registerBuildHook(hook: GlobalGraphBuildHook): void;
+  addModuleNode(moduleNode: GlobalModuleNode): void;
+  build(): void;
+  buildInjectEdge(moduleNode: GraphNode<GlobalModuleNode, ModuleDependencyMeta>, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectObj: InjectObjectDescriptor): void;
+  addInject(moduleNode: GraphNode<GlobalModuleNode, ModuleDependencyMeta>, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectName: PropertyKey): void;
+  findInjectProto(proto: ProtoDescriptor, injectObject: InjectObjectDescriptor): ProtoDescriptor | undefined;
+  findDependencyProtoNode(proto: ProtoDescriptor, injectObject: InjectObjectDescriptor): GraphNode<ProtoNode, ProtoDependencyMeta> | undefined;
+  findModuleNode(moduleName: string): GraphNode<GlobalModuleNode, ModuleDependencyMeta>;
+  sort(): void;
+  static create(moduleDescriptors: ModuleDescriptor[], options?: GlobalGraphOptions): Promise<GlobalGraph>;
+}
+//#endregion
+//#region src/model/graph/GlobalModuleNodeBuilder.d.ts
+declare class GlobalModuleNodeBuilder {
+  private readonly name;
+  private readonly unitPath;
+  private readonly optional;
+  private readonly protos;
+  constructor(options: GlobalModuleNodeOptions);
+  addClazz(clazz: EggProtoImplClass): this;
+  addMultiInstanceClazz(clazz: EggProtoImplClass, defineModuleName: string, defineUnitPath: string): Promise<this>;
+  build(): GlobalModuleNode;
+  static create(unitPath: string, optional?: boolean): GlobalModuleNodeBuilder;
+}
+//#endregion
+//#region src/model/ProtoDescriptor/AbstractProtoDescriptor.d.ts
+interface AbstractProtoDescriptorOptions {
+  name: PropertyKey;
+  accessLevel: AccessLevel;
+  initType: ObjectInitTypeLike;
+  qualifiers: QualifierInfo[];
+  protoImplType: string;
+  injectObjects: InjectObjectDescriptor[];
+  defineModuleName: string;
+  defineUnitPath: string;
+  instanceModuleName: string;
+  instanceDefineUnitPath: string;
+  type: ProtoDescriptorTypeLike;
+  properQualifiers: Record<PropertyKey, QualifierInfo[]>;
+}
+declare abstract class AbstractProtoDescriptor implements ProtoDescriptor {
+  name: PropertyKey;
+  accessLevel: AccessLevel;
+  initType: ObjectInitTypeLike;
+  qualifiers: QualifierInfo[];
+  injectObjects: InjectObjectDescriptor[];
+  protoImplType: string;
+  defineModuleName: string;
+  defineUnitPath: string;
+  instanceModuleName: string;
+  instanceDefineUnitPath: string;
+  className?: string;
+  properQualifiers: Record<PropertyKey, QualifierInfo[]>;
+  type: ProtoDescriptorTypeLike;
+  protected constructor(options: AbstractProtoDescriptorOptions);
+  abstract equal(protoDescriptor: ProtoDescriptor): boolean;
+}
+//#endregion
+//#region src/model/ProtoDescriptor/ClassProtoDescriptor.d.ts
+interface ClassProtoDescriptorOptions extends Omit<AbstractProtoDescriptorOptions, 'type'> {
+  clazz: EggProtoImplClass;
+}
+declare class ClassProtoDescriptor extends AbstractProtoDescriptor {
+  clazz: EggProtoImplClass;
+  clazzName: string;
+  static isClassProtoDescriptor(descriptor: ProtoDescriptor): descriptor is ClassProtoDescriptor;
+  constructor(options: ClassProtoDescriptorOptions);
+  equal(protoDescriptor: ProtoDescriptor): boolean;
+}
+//#endregion
+//#region src/model/AppGraph.d.ts
+interface InstanceClazzMeta {
+  name: PropertyKey;
+  qualifiers: QualifierInfo[];
+  properQualifiers: Record<PropertyKey, QualifierInfo[]>;
+  accessLevel: AccessLevel;
+  instanceModule: GraphNode<ModuleNode>;
+  ownerModule: GraphNode<ModuleNode>;
+}
+type ClazzMetaMap = Record<EggPrototypeName, InstanceClazzMeta[]>;
+declare class ClazzMap {
+  private clazzMap;
+  private graph;
+  constructor(graph: Graph<ModuleNode>);
+  build(): Promise<void>;
+  findDependencyModule(objName: EggPrototypeName, properQualifiers: QualifierInfo[], intoModule: GraphNode<ModuleNode>): GraphNode<ModuleNode>[];
+}
+declare class ModuleNode implements GraphNodeObj$1 {
+  readonly id: string;
+  readonly name: string;
+  readonly moduleConfig: ModuleReference$1;
+  private readonly clazzList;
+  constructor(moduleConfig: ModuleReference$1);
+  addClazz(clazz: EggProtoImplClass): Promise<void>;
+  toString(): string;
+  getClazzList(): readonly EggProtoImplClass[];
+}
+declare class AppGraph {
+  private graph;
+  private clazzMap;
+  moduleConfigList: Array<ModuleReference$1>;
+  constructor();
+  addNode(moduleNode: ModuleNode): void;
+  getClazzList(): readonly EggProtoImplClass[];
+  build(): Promise<void>;
+  sort(): void;
+}
+//#endregion
+//#region src/model/EggPrototype.d.ts
+declare const EggPrototypeLifecycleUtil: LifecycleUtil<EggPrototypeLifecycleContext, EggPrototype>;
+//#endregion
+//#region src/model/LoadUnit.d.ts
+declare const LoadUnitLifecycleUtil: LifecycleUtil<LoadUnitLifecycleContext, LoadUnit>;
+//#endregion
+//#region src/model/ProtoDescriptorHelper.d.ts
+declare class ProtoDescriptorHelper {
+  #private;
+  static addDefaultQualifier(qualifiers: QualifierInfo[], initType: ObjectInitTypeLike, loadUnitName: string): QualifierInfo[];
+  static createByMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): Promise<ProtoDescriptor[]>;
+  static createByDynamicMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): Promise<ProtoDescriptor[]>;
+  static createByStaticMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): ProtoDescriptor[];
+  static createByInstanceClazz(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): ProtoDescriptor;
+  static selectProto(proto: ProtoDescriptor, ctx: ProtoSelectorContext): boolean;
+}
+//#endregion
+//#region src/factory/EggPrototypeCreatorFactory.d.ts
+declare class EggPrototypeCreatorFactory {
+  private static creatorMap;
+  static registerPrototypeCreator(type: string, creator: EggPrototypeCreator): void;
+  static getPrototypeCreator(type: string): EggPrototypeCreator | undefined;
+  static createProto(clazz: EggProtoImplClass, loadUnit: LoadUnit): Promise<EggPrototype[]>;
+  static createProtoByDescriptor(protoDescriptor: ClassProtoDescriptor, loadUnit: LoadUnit): Promise<EggPrototype>;
+}
+//#endregion
+//#region src/factory/LoadUnitFactory.d.ts
+declare class LoadUnitFactory {
+  private static loadUnitCreatorMap;
+  private static loadUnitMap;
+  private static loadUnitIdMap;
+  protected static getLoanUnit(ctx: LoadUnitLifecycleContext, type: EggLoadUnitTypeLike): Promise<LoadUnit>;
+  static createLoadUnit(unitPath: string, type: EggLoadUnitTypeLike, loader: Loader): Promise<LoadUnit>;
+  static createPreloadLoadUnit(unitPath: string, type: EggLoadUnitTypeLike, loader: Loader): Promise<LoadUnit>;
+  static destroyLoadUnit(loadUnit: LoadUnit): Promise<void>;
+  static getLoadUnitById(id: Id): LoadUnit | undefined;
+  static registerLoadUnitCreator(type: EggLoadUnitTypeLike, creator: LoadUnitCreator): void;
+}
+//#endregion
+//#region src/errors.d.ts
+declare class TeggError extends FrameworkBaseError {
+  get module(): string;
+}
+declare class EggPrototypeNotFound extends TeggError {
+  constructor(protoName: EggPrototypeName, loadUnitId: string | undefined);
+}
+declare class MultiPrototypeFound extends TeggError {
+  constructor(name: EggPrototypeName, qualifier: QualifierInfo[], result?: string);
+}
+declare class IncompatibleProtoInject extends TeggError {
+  constructor(msg: string);
+}
+//#endregion
+//#region src/util/ClassUtil.d.ts
+declare class ClassUtil {
+  static classDescription(clazz: EggProtoImplClass): string;
+  static className(clazz: EggProtoImplClass): string;
+}
+//#endregion
+//#region src/impl/EggPrototypeBuilder.d.ts
+declare class EggPrototypeBuilder {
+  private clazz;
+  private name;
+  private initType;
+  private accessLevel;
+  private filepath;
+  private injectType;
+  private injectObjects;
+  private loadUnit;
+  private qualifiers;
+  private properQualifiers;
+  private className?;
+  private multiInstanceConstructorIndex?;
+  private multiInstanceConstructorAttributes?;
+  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
+  private tryFindDefaultPrototype;
+  private tryFindContextPrototype;
+  private tryFindSelfInitTypePrototype;
+  private findInjectObjectPrototype;
+  build(): EggPrototype;
+}
+//#endregion
+//#region src/impl/EggPrototypeImpl.d.ts
+declare class EggPrototypeImpl implements EggPrototype {
+  private readonly clazz;
+  private readonly qualifiers;
+  readonly filepath: string;
+  readonly id: string;
+  readonly name: EggPrototypeName;
+  readonly initType: ObjectInitTypeLike;
+  readonly accessLevel: AccessLevel;
+  readonly injectObjects: Array<InjectObjectProto | InjectConstructorProto>;
+  readonly injectType: InjectType;
+  readonly loadUnitId: Id;
+  readonly className?: string;
+  readonly multiInstanceConstructorIndex?: number;
+  readonly multiInstanceConstructorAttributes?: QualifierAttribute[];
+  [key: symbol]: PropertyDescriptor;
+  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, filepath: string, initType: ObjectInitTypeLike, accessLevel: AccessLevel, injectObjectMap: Array<InjectObjectProto | InjectConstructorProto>, loadUnitId: Id, qualifiers: QualifierInfo[], className?: string, injectType?: InjectType, multiInstanceConstructorIndex?: number, multiInstanceConstructorAttributes?: QualifierAttribute[]);
+  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
+  verifyQualifier(qualifier: QualifierInfo): boolean;
+  getQualifier(attribute: string): QualifierValue | undefined;
+  constructEggObject(...args: any): object;
+  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
+}
+//#endregion
+//#region src/impl/LoadUnitMultiInstanceProtoHook.d.ts
+declare class LoadUnitMultiInstanceProtoHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  static multiInstanceClazzSet: Set<EggProtoImplClass>;
+  static setAllClassList(clazzList: readonly EggProtoImplClass[]): void;
+  static clear(): void;
+  preCreate(): Promise<void>;
+}
+//#endregion
+//#region src/impl/ModuleLoadUnit.d.ts
+declare class ModuleGraph {
+  private graph;
+  clazzList: EggProtoImplClass[];
+  readonly unitPath: string;
+  readonly name: string;
+  constructor(clazzList: EggProtoImplClass[], unitPath: string, name: string);
+  private findInjectNode;
+  build(): Promise<void>;
+  sort(): void;
+}
+declare class ModuleLoadUnit implements LoadUnit {
+  private protoMap;
+  private protos;
+  private clazzList;
+  readonly id: string;
+  readonly name: string;
+  readonly unitPath: string;
+  readonly type = EggLoadUnitType.MODULE;
+  get globalGraph(): GlobalGraph;
+  constructor(name: string, unitPath: string);
+  private doLoadClazz;
+  private loadClazz;
+  preLoad(): Promise<void>;
+  init(): Promise<void>;
+  containPrototype(proto: EggPrototype): boolean;
+  getEggPrototype(name: string, qualifiers: QualifierInfo[]): EggPrototype[];
+  registerEggPrototype(proto: EggPrototype): void;
+  deletePrototype(proto: EggPrototype): void;
+  destroy(): Promise<void>;
+  iterateEggPrototype(): IterableIterator<EggPrototype>;
+  static createModule(ctx: LoadUnitLifecycleContext): ModuleLoadUnit;
+}
+//#endregion
 export { AbstractProtoDescriptor, AbstractProtoDescriptorOptions, AppGraph, ClassProtoDescriptor, ClassProtoDescriptorOptions, ClassUtil, ClazzMap, ClazzMetaMap, EggPrototypeBuilder, EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeImpl, EggPrototypeLifecycleUtil, EggPrototypeNotFound, GlobalGraph, GlobalGraphBuildHook, GlobalGraphOptions, GlobalModuleNode, GlobalModuleNodeBuilder, GlobalModuleNodeOptions, IncompatibleProtoInject, InstanceClazzMeta, LoadUnitFactory, LoadUnitLifecycleUtil, LoadUnitMultiInstanceProtoHook, ModuleDependencyMeta, ModuleDescriptor, ModuleDescriptorDumper, ModuleDumpOptions, ModuleGraph, ModuleLoadUnit, ModuleNode, MultiPrototypeFound, ProtoDependencyMeta, ProtoDescriptorHelper, ProtoNode, ProtoSelectorContext, TeggError };