@module-federation/enhanced 0.1.5 → 0.1.6

package/dist/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@module-federation/enhanced",
+  "version": "0.1.6",
+  "main": "./src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "webpack": "^5.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "require": "./dist/src/index.js",
+      "import": "./dist/src/index.js"
+    },
+    "./webpack": {
+      "types": "./dist/src/webpack.d.ts",
+      "require": "./dist/src/webpack.js",
+      "import": "./dist/src/webpack.js"
+    },
+    "./rspack": {
+      "types": "./dist/src/rspack.d.ts",
+      "require": "./dist/src/rspack.js",
+      "import": "./dist/src/rspack.js"
+    },
+    "./runtime": {
+      "types": "./dist/src/runtime.d.ts",
+      "require": "./dist/src/runtime.js",
+      "import": "./dist/src/runtime.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/src/index.d.ts"
+      ],
+      "webpack": [
+        "./dist/src/webpack.d.ts"
+      ],
+      "rspack": [
+        "./dist/src/rspack.d.ts"
+      ],
+      "runtime": [
+        "./dist/src/runtime.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@module-federation/webpack-bundler-runtime": "workspace:*"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "workspace:*",
+    "@module-federation/runtime-tools": "workspace:*",
+    "@module-federation/manifest": "workspace:*",
+    "@module-federation/managers": "workspace:*",
+    "@module-federation/dts-plugin": "workspace:*",
+    "@module-federation/rspack": "workspace:*",
+    "upath": "2.0.1"
+  },
+  "type": "commonjs"
+}

package/dist/src/declarations/plugins/container/AsyncDependenciesBlock.d.ts

@@ -0,0 +1,57 @@
+export class AsyncDependenciesBlock extends DependenciesBlock {
+  /**
+   * @param {(ChunkGroupOptions & { entryOptions?: EntryOptions }) | null} groupOptions options for the group
+   * @param {(DependencyLocation | null)=} loc the line of code
+   * @param {(string | null)=} request the request
+   */
+  constructor(
+    groupOptions:
+      | (ChunkGroupOptions & {
+          entryOptions?: EntryOptions;
+        })
+      | null,
+    loc?: (DependencyLocation | null) | undefined,
+    request?: (string | null) | undefined,
+  );
+  groupOptions: import('./ChunkGroup').RawChunkGroupOptions & {
+    name?: string | undefined;
+  } & {
+    entryOptions?: import('./Entrypoint').EntryOptions | undefined;
+  };
+  loc: import('./Dependency').DependencyLocation | null | undefined;
+  request: string | null | undefined;
+  _stringifiedGroupOptions: string | undefined;
+  /**
+   * @param {string | undefined} value The new chunk name
+   * @returns {void}
+   */
+  set chunkName(arg: string | undefined);
+  /**
+   * @returns {string | undefined} The name of the chunk
+   */
+  get chunkName(): string | undefined;
+  set module(arg: any);
+  get module(): any;
+}
+declare namespace AsyncDependenciesBlock {
+  export {
+    ChunkGraph,
+    ChunkGroup,
+    ChunkGroupOptions,
+    DependencyLocation,
+    UpdateHashContext,
+    EntryOptions,
+    Module,
+    ObjectDeserializerContext,
+    ObjectSerializerContext,
+    Hash,
+  };
+}
+import DependenciesBlock = require('./DependenciesBlock');
+type ChunkGroupOptions = import('./ChunkGroup').ChunkGroupOptions;
+type EntryOptions = import('./Entrypoint').EntryOptions;
+type DependencyLocation = import('./Dependency').DependencyLocation;
+type ChunkGraph = import('./ChunkGraph');
+type ChunkGroup = import('./ChunkGroup');
+type UpdateHashContext = import('./Dependency').UpdateHashContext;
+type Hash = import('./util/Hash');

package/dist/src/declarations/plugins/container/Dependency.d.ts

@@ -0,0 +1,285 @@
+export class Dependency {
+  /** @type {Module | undefined} */
+  _parentModule: Module | undefined;
+  /** @type {DependenciesBlock | undefined} */
+  _parentDependenciesBlock: DependenciesBlock | undefined;
+  /** @type {number} */
+  _parentDependenciesBlockIndex: number;
+  /** @type {boolean} */
+  weak: boolean;
+  /** @type {boolean} */
+  optional: boolean;
+  _locSL: number;
+  _locSC: number;
+  _locEL: number;
+  _locEC: number;
+  _locI: any;
+  _locN: any;
+  _loc:
+    | DependencyLocation
+    | (SyntheticDependencyLocation & RealDependencyLocation)
+    | undefined;
+  /**
+   * @returns {string} a display name for the type of dependency
+   */
+  get type(): string;
+  /**
+   * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
+   */
+  get category(): string;
+  set loc(arg: DependencyLocation);
+  /**
+   * @returns {DependencyLocation} location
+   */
+  get loc(): DependencyLocation;
+  /**
+   * @param {number} startLine start line
+   * @param {number} startColumn start column
+   * @param {number} endLine end line
+   * @param {number} endColumn end column
+   */
+  setLoc(
+    startLine: number,
+    startColumn: number,
+    endLine: number,
+    endColumn: number,
+  ): void;
+  /**
+   * @returns {string | undefined} a request context
+   */
+  getContext(): string | undefined;
+  /**
+   * @returns {string | null} an identifier to merge equal requests
+   */
+  getResourceIdentifier(): string | null;
+  /**
+   * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+   */
+  couldAffectReferencingModule(): boolean | typeof TRANSITIVE;
+  /**
+   * Returns the referenced module and export
+   * @deprecated
+   * @param {ModuleGraph} moduleGraph module graph
+   * @returns {never} throws error
+   */
+  getReference(moduleGraph: ModuleGraph): never;
+  /**
+   * Returns list of exports referenced by this dependency
+   * @param {ModuleGraph} moduleGraph module graph
+   * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+   * @returns {(string[] | ReferencedExport)[]} referenced exports
+   */
+  getReferencedExports(
+    moduleGraph: ModuleGraph,
+    runtime: RuntimeSpec,
+  ): (string[] | ReferencedExport)[];
+  /**
+   * @param {ModuleGraph} moduleGraph module graph
+   * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+   */
+  getCondition(
+    moduleGraph: ModuleGraph,
+  ):
+    | false
+    | ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState)
+    | null;
+  /**
+   * Returns the exported names
+   * @param {ModuleGraph} moduleGraph module graph
+   * @returns {ExportsSpec | undefined} export names
+   */
+  getExports(moduleGraph: ModuleGraph): ExportsSpec | undefined;
+  /**
+   * Returns warnings
+   * @param {ModuleGraph} moduleGraph module graph
+   * @returns {WebpackError[] | null | undefined} warnings
+   */
+  getWarnings(moduleGraph: ModuleGraph): WebpackError[] | null | undefined;
+  /**
+   * Returns errors
+   * @param {ModuleGraph} moduleGraph module graph
+   * @returns {WebpackError[] | null | undefined} errors
+   */
+  getErrors(moduleGraph: ModuleGraph): WebpackError[] | null | undefined;
+  /**
+   * Update the hash
+   * @param {Hash} hash hash to be updated
+   * @param {UpdateHashContext} context context
+   * @returns {void}
+   */
+  updateHash(hash: Hash, context: UpdateHashContext): void;
+  /**
+   * implement this method to allow the occurrence order plugin to count correctly
+   * @returns {number} count how often the id is used in this dependency
+   */
+  getNumberOfIdOccurrences(): number;
+  /**
+   * @param {ModuleGraph} moduleGraph the module graph
+   * @returns {ConnectionState} how this dependency connects the module to referencing modules
+   */
+  getModuleEvaluationSideEffectsState(
+    moduleGraph: ModuleGraph,
+  ): ConnectionState;
+  /**
+   * @param {string} context context directory
+   * @returns {Module | null} a module
+   */
+  createIgnoredModule(context: string): Module | null;
+  /**
+   * @param {ObjectSerializerContext} context context
+   */
+  serialize({ write }: ObjectSerializerContext): void;
+  /**
+   * @param {ObjectDeserializerContext} context context
+   */
+  deserialize({ read }: ObjectDeserializerContext): void;
+  set module(arg: any);
+  get module(): any;
+  get disconnect(): any;
+}
+declare namespace Dependency {
+  export {
+    NO_EXPORTS_REFERENCED,
+    EXPORTS_OBJECT_REFERENCED,
+    TRANSITIVE,
+    Source,
+    ChunkGraph,
+    DependenciesBlock,
+    DependencyTemplates,
+    Module,
+    ModuleGraph,
+    ModuleGraphConnection,
+    ConnectionState,
+    RuntimeTemplate,
+    WebpackError,
+    ObjectDeserializerContext,
+    ObjectSerializerContext,
+    Hash,
+    RuntimeSpec,
+    UpdateHashContext,
+    SourcePosition,
+    RealDependencyLocation,
+    SyntheticDependencyLocation,
+    DependencyLocation,
+    ExportSpec,
+    ExportsSpec,
+    ReferencedExport,
+  };
+}
+type Module = import('./Module');
+type DependenciesBlock = import('./DependenciesBlock');
+type DependencyLocation = SyntheticDependencyLocation | RealDependencyLocation;
+type SyntheticDependencyLocation = {
+  name: string;
+  index?: number | undefined;
+};
+type RealDependencyLocation = {
+  start: SourcePosition;
+  end?: SourcePosition | undefined;
+  index?: number | undefined;
+};
+
+declare const TRANSITIVE: unique symbol;
+type ModuleGraph = import('./ModuleGraph');
+type RuntimeSpec = import('./util/runtime').RuntimeSpec;
+type ReferencedExport = {
+  /**
+   * name of the referenced export
+   */
+  name: string[];
+  /**
+   * when false, referenced export can not be mangled, defaults to true
+   */
+  canMangle?: boolean | undefined;
+};
+type ModuleGraphConnection = import('./ModuleGraphConnection');
+type ConnectionState = import('./ModuleGraphConnection').ConnectionState;
+type ExportsSpec = {
+  /**
+   * exported names, true for unknown exports or null for no exports
+   */
+  exports: (string | ExportSpec)[] | true | null;
+  /**
+   * when exports = true, list of unaffected exports
+   */
+  excludeExports?: Set<string> | undefined;
+  /**
+   * list of maybe prior exposed, but now hidden exports
+   */
+  hideExports?: Set<string> | undefined;
+  /**
+   * when reexported: from which module
+   */
+  from?: ModuleGraphConnection | undefined;
+  /**
+   * when reexported: with which priority
+   */
+  priority?: number | undefined;
+  /**
+   * can the export be renamed (defaults to true)
+   */
+  canMangle?: boolean | undefined;
+  /**
+   * are the exports terminal bindings that should be checked for export star conflicts
+   */
+  terminalBinding?: boolean | undefined;
+  /**
+   * module on which the result depends on
+   */
+  dependencies?: Module[] | undefined;
+};
+type WebpackError = import('./WebpackError');
+type Hash = import('./util/Hash');
+type UpdateHashContext = {
+  chunkGraph: ChunkGraph;
+  runtime: RuntimeSpec;
+  runtimeTemplate?: RuntimeTemplate | undefined;
+};
+type ObjectSerializerContext =
+  import('./serialization/ObjectMiddleware').ObjectSerializerContext;
+type ObjectDeserializerContext =
+  import('./serialization/ObjectMiddleware').ObjectDeserializerContext;
+declare const NO_EXPORTS_REFERENCED: string[][];
+declare const EXPORTS_OBJECT_REFERENCED: string[][];
+type Source = import('webpack-sources').Source;
+type ChunkGraph = import('./ChunkGraph');
+type DependencyTemplates = import('./DependencyTemplates');
+type RuntimeTemplate = import('./RuntimeTemplate');
+type SourcePosition = {
+  line: number;
+  column?: number | undefined;
+};
+type ExportSpec = {
+  /**
+   * the name of the export
+   */
+  name: string;
+  /**
+   * can the export be renamed (defaults to true)
+   */
+  canMangle?: boolean | undefined;
+  /**
+   * is the export a terminal binding that should be checked for export star conflicts
+   */
+  terminalBinding?: boolean | undefined;
+  /**
+   * nested exports
+   */
+  exports?: (string | ExportSpec)[] | undefined;
+  /**
+   * when reexported: from which module
+   */
+  from?: ModuleGraphConnection | undefined;
+  /**
+   * when reexported: from which export
+   */
+  export?: (string[] | null) | undefined;
+  /**
+   * when reexported: with which priority
+   */
+  priority?: number | undefined;
+  /**
+   * export is not visible, because another export blends over it
+   */
+  hidden?: boolean | undefined;
+};

package/dist/src/declarations/plugins/container/Module.d.ts

@@ -0,0 +1,138 @@
+declare class Module extends DependenciesBlock {
+  constructor(type: string, context?: null | string, layer?: null | string);
+  type: string;
+  context: null | string;
+  layer: null | string;
+  needId: boolean;
+  debugId: number;
+  resolveOptions?: ResolveOptionsWebpackOptions;
+  factoryMeta?: FactoryMeta;
+  useSourceMap: boolean;
+  useSimpleSourceMap: boolean;
+  buildMeta?: BuildMeta;
+  buildInfo?: BuildInfo;
+  presentationalDependencies?: Dependency[];
+  codeGenerationDependencies?: Dependency[];
+  id: string | number;
+  get hash(): string;
+  get renderedHash(): string;
+  profile: null | ModuleProfile;
+  index: null | number;
+  index2: null | number;
+  depth: null | number;
+  issuer: null | Module;
+  get usedExports(): null | boolean | SortableSet<string>;
+  get optimizationBailout(): (
+    | string
+    | ((requestShortener: RequestShortener) => string)
+  )[];
+  get optional(): boolean;
+  addChunk(chunk: Chunk): boolean;
+  removeChunk(chunk: Chunk): void;
+  isInChunk(chunk: Chunk): boolean;
+  isEntryModule(): boolean;
+  getChunks(): Chunk[];
+  getNumberOfChunks(): number;
+  get chunksIterable(): Iterable<Chunk>;
+  isProvided(exportName: string): null | boolean;
+  get exportsArgument(): string;
+  get moduleArgument(): string;
+  getExportsType(
+    moduleGraph: ModuleGraph,
+    strict?: boolean,
+  ): 'namespace' | 'default-only' | 'default-with-named' | 'dynamic';
+  addPresentationalDependency(presentationalDependency: Dependency): void;
+  addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
+  addWarning(warning: WebpackError): void;
+  getWarnings(): undefined | Iterable<WebpackError>;
+  getNumberOfWarnings(): number;
+  addError(error: WebpackError): void;
+  getErrors(): undefined | Iterable<WebpackError>;
+  getNumberOfErrors(): number;
+
+  /**
+   * removes all warnings and errors
+   */
+  clearWarningsAndErrors(): void;
+  isOptional(moduleGraph: ModuleGraph): boolean;
+  isAccessibleInChunk(
+    chunkGraph: ChunkGraph,
+    chunk: Chunk,
+    ignoreChunk?: Chunk,
+  ): boolean;
+  isAccessibleInChunkGroup(
+    chunkGraph: ChunkGraph,
+    chunkGroup: ChunkGroup,
+    ignoreChunk?: Chunk,
+  ): boolean;
+  hasReasonForChunk(
+    chunk: Chunk,
+    moduleGraph: ModuleGraph,
+    chunkGraph: ChunkGraph,
+  ): boolean;
+  hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
+  needBuild(
+    context: NeedBuildContext,
+    callback: (arg0?: null | WebpackError, arg1?: boolean) => void,
+  ): void;
+  needRebuild(
+    fileTimestamps: Map<string, null | number>,
+    contextTimestamps: Map<string, null | number>,
+  ): boolean;
+  invalidateBuild(): void;
+  identifier(): string;
+  readableIdentifier(requestShortener: RequestShortener): string;
+  build(
+    options: WebpackOptionsNormalized,
+    compilation: Compilation,
+    resolver: ResolverWithOptions,
+    fs: InputFileSystem,
+    callback: (arg0?: WebpackError) => void,
+  ): void;
+  getSourceTypes(): Set<string>;
+  source(
+    dependencyTemplates: DependencyTemplates,
+    runtimeTemplate: RuntimeTemplate,
+    type?: string,
+  ): Source;
+  size(type?: string): number;
+  libIdent(options: LibIdentOptions): null | string;
+  nameForCondition(): null | string;
+  getConcatenationBailoutReason(
+    context: ConcatenationBailoutReasonContext,
+  ): undefined | string;
+  getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
+  codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
+  chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
+  hasChunkCondition(): boolean;
+
+  /**
+   * Assuming this module is in the cache. Update the (cached) module with
+   * the fresh module from the factory. Usually updates internal references
+   * and properties.
+   */
+  updateCacheModule(module: Module): void;
+
+  /**
+   * Module should be unsafe cached. Get data that's needed for that.
+   * This data will be passed to restoreFromUnsafeCache later.
+   */
+  getUnsafeCacheData(): object;
+
+  /**
+   * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+   */
+  cleanupForCache(): void;
+  originalSource(): null | Source;
+  addCacheDependencies(
+    fileDependencies: LazySet<string>,
+    contextDependencies: LazySet<string>,
+    missingDependencies: LazySet<string>,
+    buildDependencies: LazySet<string>,
+  ): void;
+  get hasEqualsChunks(): any;
+  get isUsed(): any;
+  get errors(): any;
+  get warnings(): any;
+  used: any;
+}

package/dist/src/declarations/plugins/container/ModuleFactory.d.ts

@@ -0,0 +1,33 @@
+declare abstract class ModuleFactory {
+  create(
+    data: ModuleFactoryCreateData,
+    callback: (arg0?: null | Error, arg1?: ModuleFactoryResult) => void,
+  ): void;
+}
+
+declare interface ModuleFactoryCreateData {
+  contextInfo: ModuleFactoryCreateDataContextInfo;
+  resolveOptions?: ResolveOptionsWebpackOptions;
+  context: string;
+  dependencies: Dependency[];
+}
+
+declare interface ModuleFactoryCreateDataContextInfo {
+  issuer: string;
+  issuerLayer?: null | string;
+  compiler: string;
+}
+declare interface ModuleFactoryResult {
+  /**
+   * the created module or unset if no module was created
+   */
+  module?: Module;
+  fileDependencies?: Set<string>;
+  contextDependencies?: Set<string>;
+  missingDependencies?: Set<string>;
+
+  /**
+   * allow to use the unsafe cache
+   */
+  cacheable?: boolean;
+}

package/dist/src/declarations/plugins/container/ObjectDeserializerContext.d.ts

@@ -0,0 +1,4 @@
+export type ObjectDeserializerContext = {
+  read: () => any;
+  setCircularReference: (arg0: any) => void;
+};

package/dist/src/declarations/plugins/container/StaticExportsDependency.d.ts

@@ -0,0 +1,28 @@
+export class StaticExportsDependency extends NullDependency {
+  /**
+   * @param {string[] | true} exports export names
+   * @param {boolean} canMangle true, if mangling exports names is allowed
+   */
+  constructor(exports: string[] | true, canMangle: boolean);
+  exports: true | string[];
+  canMangle: boolean;
+}
+declare namespace StaticExportsDependency {
+  export {
+    ChunkGraph,
+    ExportSpec,
+    ExportsSpec,
+    UpdateHashContext,
+    ModuleGraph,
+    ObjectDeserializerContext,
+    ObjectSerializerContext,
+    Hash,
+  };
+}
+import NullDependency = require('./NullDependency');
+type ChunkGraph = import('../ChunkGraph');
+type ExportSpec = import('./Dependency').ExportSpec;
+type ExportsSpec = import('./Dependency').ExportsSpec;
+type UpdateHashContext = import('./Dependency').UpdateHashContext;
+type ModuleGraph = import('../ModuleGraph');
+type Hash = import('../util/Hash');