@module-federation/enhanced 0.2.0-canary.5 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson) Zhou Shaw (zhouxiao)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# `@module-federation/enhanced`
+
+This package provides enhanced features for module federation.
+
+The following items are exported:
+
+- ModuleFederationPlugin
+- ContainerPlugin
+- ContainerReferencePlugin
+- SharePlugin
+- ConsumeSharedPlugin
+- ProvideSharedPlugin
+- FederationRuntimePlugin
+- AsyncBoundaryPlugin
+- HoistContainerReferencesPlugin
+
+## ModuleFederationPlugin
+
+### Configuration
+
+### name
+
+- Type: `string`
+- Required: No
+
+The name of the container.
+
+### exposes
+
+- Type: `Exposes`
+- Required: No
+- Default: `undefined`
+
+Used to specify the modules and file entry points that are exposed via Module Federation. After configuration, the exposed modules will be extracted into a separate chunk, and if there are async chunks, they will also be extracted into a separate chunk (the specific splitting behavior depends on the chunk splitting rules).
+
+The `Exposes` type is defined as follows:
+
+```tsx
+type Exposes = (ExposesItem | ExposesObject)[] | ExposesObject;
+
+type ExposesItem = string;
+
+type ExposesItems = ExposesItem[];
+
+interface ExposesObject {
+  [exposeKey: string]: ExposesConfig | ExposesItem | ExposesItems;
+}
+```
+
+Here, `exposeKey` is essentially the same as the [Package Entry Points](https://nodejs.org/api/packages.html#package-entry-points) specification (except that regular expression matching is not supported).
+
+For example:
+
+```jsx
+module.exports = {
+  plugins: [
+    new ModuleFederationPlugin({
+      name: 'mfButton',
+      exposes: {
+        // Note: "./" is not supported
+        '.': './src/index.tsx',
+        './add': './src/utils/add.ts',
+        './Button': './src/components/Button.tsx',
+      },
+    }),
+  ],
+};
+```
+
+### remotes
+
+> This is a consumer-specific parameter. If remotes is set, it can be considered as a consumer.
+
+- Type: `Remotes`
+- Required: No
+- Default: `undefined`
+
+This is used to specify how Module Federation consumes remote modules.
+
+The `Remotes` type is defined as follows:
+
+```tsx
+type Remotes = (RemotesItem | RemotesObject)[] | RemotesObject;
+
+type RemotesItem = string;
+type RemotesItems = RemotesItem[];
+
+interface RemotesObject {
+  [remoteAlias: string]: RemotesConfig | RemotesItem | RemotesItems;
+}
+```
+
+Here, `remoteAlias` is the name actually used by the user and can be configured arbitrarily. For example, if `remoteAlias` is set to `demo`, the consumption method is `import xx from 'demo'`.
+
+### shared
+
+- Type: `Shared`
+- Required: No
+- Default: `undefined`
+
+`shared` is used to share common dependencies between consumers and producers, reducing runtime download size and thus improving performance.
+
+The `Shared` type is defined as follows:
+
+```tsx
+type Shared = (SharedItem | SharedObject)[] | SharedObject;
+
+type SharedItem = string;
+
+interface SharedObject {
+  [k: string]: SharedConfig | SharedItem;
+}
+```
+
+#### singleton
+
+- Type: `boolean`
+- Required: No
+- Default: `false`
+
+Determines whether only one version of the shared module is allowed in the shared scope (singleton mode).
+
+- If the value is true, singleton mode is enabled; if the value is false, singleton mode is not enabled.
+- If singleton mode is enabled, the shared dependencies of the remote application components and host application are loaded only once, and a higher version is loaded when the versions are not consistent. At this time, a warning will be given to the lower version side:
+- If singleton mode is not enabled, if the versions of shared dependencies between the remote application and host application are not consistent, the remote application and host application load their own dependencies
+
+#### requiredVersion
+
+- Type: `string`
+- Required: False
+- Default: `require('project/package.json')[devDeps | dep]['depName']`
+
+The required version can be a version range. The default value is the dependency version of the current application.
+
+- When using shared dependencies, it will be judged whether the dependency version meets requiredVersion. If it does, it will be used normally. If it is less than requiredVersion, a warning will be issued in the console, and the smallest version in the current shared dependency will be used.
+- When one side sets requiredVersion and the other side sets singleton, the dependency of requiredVersion will be loaded, and the singleton side will directly use the dependency of requiredVersion, regardless of the version.
+
+#### eager
+
+:::warning
+When `eager` is set to true, the shared dependencies will be packaged into the entry file, which will cause the entry file to be too large. Please open with caution.
+`eager: true` is rarely recommended
+:::
+
+- Type: `boolean`
+- Required: False
+- Default: `false`
+
+Determines whether to load shared modules immediately.
+
+Under normal circumstances, you need to open the asynchronous entry, and then load shared asynchronously on demand. If you want to use shared but don't want to enable asynchronous entry, you can set `eager` to true .
+
+### runtimePlugins
+
+- Type: `string[]`
+- Required: False
+- Default: `undefined`
+
+Used to add additional plug-ins required at runtime. The value is the path of the specific plug-in. It supports absolute/relative paths and package names.
+
+Once set, the runtime plugin is automatically injected and used at build time.
+
+### implementation
+
+- Type: `string`
+- Required: False
+- Default: `undefined`
+
+Used to modify the actual bundler runtime version. Path with value `@module-federation/runtime-tools`.

package/dist/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@module-federation/enhanced",
+  "version": "0.2.1",
+  "main": "./src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "repository": "https://github.com/module-federation/core/tree/main/packages/enhanced",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "webpack": "^5.0.0",
+    "typescript": "^4.9.0 || ^5.0.0",
+    "vue-tsc": "^1.0.24"
+  },
+  "peerDependenciesMeta": {
+    "webpack": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    },
+    "vue-tsc": {
+      "optional": true
+    }
+  },
+  "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:*",
+    "@types/btoa": "^1.2.5"
+  },
+  "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:*",
+    "@module-federation/bridge-react-webpack-plugin": "workspace:*",
+    "upath": "2.0.1",
+    "btoa": "^1.2.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;
+};