@module-federation/enhanced 0.0.7 → 0.0.9

package/README.md

@@ -1,11 +1,169 @@
-# enhanced
+# `@module-federation/enhanced`
 
-This library was generated with [Nx](https://nx.dev).
+This package provides enhanced features for module federation.
 
-## Building
+The following items are exported:
 
-Run `nx build enhanced` to build the library.
+* ModuleFederationPlugin
+* ContainerPlugin
+* ContainerReferencePlugin
+* SharePlugin
+* ConsumeSharedPlugin
+* ProvideSharedPlugin
+* FederationRuntimePlugin
+* AsyncBoundaryPlugin
+* HoistContainerReferencesPlugin
 
-## Running unit tests
+## ModuleFederationPlugin
 
-Run `nx test enhanced` to execute the unit tests via [Jest](https://jestjs.io).
+### 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

@@ -1,7 +1,6 @@
 {
   "name": "@module-federation/enhanced",
-  "version": "0.0.7",
-  "type": "commonjs",
+  "version": "0.0.9",
   "main": "./src/index.js",
   "types": "./dist/src/index.d.ts",
   "files": [
@@ -17,6 +16,7 @@
   "exports": {
     ".": {
       "require": "./dist/src/index.js",
+      "import": "./dist/src/index.js",
       "types": "./dist/index.d.ts"
     }
   },
@@ -27,7 +27,12 @@
       ]
     }
   },
+  "devDependencies": {
+    "@module-federation/webpack-bundler-runtime": "workspace:*"
+  },
   "dependencies": {
-    "@module-federation/sdk": "workspace:*"
-  }
+    "@module-federation/sdk": "workspace:*",
+    "@module-federation/runtime-tools": "workspace:*"
+  },
+  "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/ContainerPlugin.d.ts

@@ -0,0 +1,187 @@
+/*
+ * This file was automatically generated.
+ * DO NOT MODIFY BY HAND.
+ * Run `yarn special-lint-fix` to update
+ */
+
+/**
+ * Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
+ */
+export type Exposes = (ExposesItem | ExposesObject)[] | ExposesObject;
+/**
+ * Module that should be exposed by this container.
+ */
+export type ExposesItem = string;
+/**
+ * Modules that should be exposed by this container.
+ */
+export type ExposesItems = ExposesItem[];
+/**
+ * Add a container for define/require functions in the AMD module.
+ */
+export type AmdContainer = string;
+/**
+ * Add a comment in the UMD wrapper.
+ */
+export type AuxiliaryComment = string | LibraryCustomUmdCommentObject;
+/**
+ * Specify which export should be exposed as library.
+ */
+export type LibraryExport = string[] | string;
+/**
+ * The name of the library (some types allow unnamed libraries too).
+ */
+export type LibraryName = string[] | string | LibraryCustomUmdObject;
+/**
+ * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
+ */
+export type LibraryType =
+  | (
+      | 'var'
+      | 'module'
+      | 'assign'
+      | 'assign-properties'
+      | 'this'
+      | 'window'
+      | 'self'
+      | 'global'
+      | 'commonjs'
+      | 'commonjs2'
+      | 'commonjs-module'
+      | 'commonjs-static'
+      | 'amd'
+      | 'amd-require'
+      | 'umd'
+      | 'umd2'
+      | 'jsonp'
+      | 'system'
+    )
+  | string;
+/**
+ * If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.
+ */
+export type UmdNamedDefine = boolean;
+/**
+ * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
+ */
+export type EntryRuntime = false | string;
+
+export interface ContainerPluginOptions {
+  /**
+   * Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
+   */
+  exposes: Exposes;
+  /**
+   * The filename for this container relative path inside the `output.path` directory.
+   */
+  filename?: string;
+  /**
+   * Options for library.
+   */
+  library?: LibraryOptions;
+  /**
+   * The name for this container.
+   */
+  name: string;
+  /**
+   * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
+   */
+  runtime?: EntryRuntime;
+  /**
+   * The name of the share scope which is shared with the host (defaults to 'default').
+   */
+  shareScope?: string;
+  /**
+   * Runtime plugin file paths or package name.
+   */
+  runtimePlugins?: string[];
+}
+/**
+ * Modules that should be exposed by this container. Property names are used as public paths.
+ */
+export interface ExposesObject {
+  /**
+   * Modules that should be exposed by this container.
+   */
+  [k: string]: ExposesConfig | ExposesItem | ExposesItems;
+}
+/**
+ * Advanced configuration for modules that should be exposed by this container.
+ */
+export interface ExposesConfig {
+  /**
+   * Request to a module that should be exposed by this container.
+   */
+  import: ExposesItem | ExposesItems;
+  /**
+   * Custom chunk name for the exposed module.
+   */
+  name?: string;
+}
+/**
+ * Options for library.
+ */
+export interface LibraryOptions {
+  /**
+   * Add a container for define/require functions in the AMD module.
+   */
+  amdContainer?: AmdContainer;
+  /**
+   * Add a comment in the UMD wrapper.
+   */
+  auxiliaryComment?: AuxiliaryComment;
+  /**
+   * Specify which export should be exposed as library.
+   */
+  export?: LibraryExport;
+  /**
+   * The name of the library (some types allow unnamed libraries too).
+   */
+  name?: LibraryName;
+  /**
+   * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
+   */
+  type: LibraryType;
+  /**
+   * If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.
+   */
+  umdNamedDefine?: UmdNamedDefine;
+}
+/**
+ * Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.
+ */
+export interface LibraryCustomUmdCommentObject {
+  /**
+   * Set comment for `amd` section in UMD.
+   */
+  amd?: string;
+  /**
+   * Set comment for `commonjs` (exports) section in UMD.
+   */
+  commonjs?: string;
+  /**
+   * Set comment for `commonjs2` (module.exports) section in UMD.
+   */
+  commonjs2?: string;
+  /**
+   * Set comment for `root` (global variable) section in UMD.
+   */
+  root?: string;
+}
+/**
+ * Description object for all UMD variants of the library name.
+ */
+export interface LibraryCustomUmdObject {
+  /**
+   * Name of the exposed AMD library in the UMD.
+   */
+  amd?: string;
+  /**
+   * Name of the exposed commonjs export in the UMD.
+   */
+  commonjs?: string;
+  /**
+   * Name of the property exposed globally by a UMD library.
+   */
+  root?: string[] | string;
+}

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

@@ -0,0 +1,80 @@
+/*
+ * This file was automatically generated.
+ * DO NOT MODIFY BY HAND.
+ * Run `yarn special-lint-fix` to update
+ */
+
+/**
+ * Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).
+ */
+export type ExternalsType =
+  | 'var'
+  | 'module'
+  | 'assign'
+  | 'this'
+  | 'window'
+  | 'self'
+  | 'global'
+  | 'commonjs'
+  | 'commonjs2'
+  | 'commonjs-module'
+  | 'commonjs-static'
+  | 'amd'
+  | 'amd-require'
+  | 'umd'
+  | 'umd2'
+  | 'jsonp'
+  | 'system'
+  | 'promise'
+  | 'import'
+  | 'script'
+  | 'node-commonjs';
+/**
+ * Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
+ */
+export type Remotes = (RemotesItem | RemotesObject)[] | RemotesObject;
+/**
+ * Container location from which modules should be resolved and loaded at runtime.
+ */
+export type RemotesItem = string;
+/**
+ * Container locations from which modules should be resolved and loaded at runtime.
+ */
+export type RemotesItems = RemotesItem[];
+
+export interface ContainerReferencePluginOptions {
+  /**
+   * The external type of the remote containers.
+   */
+  remoteType: ExternalsType;
+  /**
+   * Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
+   */
+  remotes: Remotes;
+  /**
+   * The name of the share scope shared with all remotes (defaults to 'default').
+   */
+  shareScope?: string;
+}
+/**
+ * Container locations from which modules should be resolved and loaded at runtime. Property names are used as request scopes.
+ */
+export interface RemotesObject {
+  /**
+   * Container locations from which modules should be resolved and loaded at runtime.
+   */
+  [k: string]: RemotesConfig | RemotesItem | RemotesItems;
+}
+/**
+ * Advanced configuration for container locations from which modules should be resolved and loaded at runtime.
+ */
+export interface RemotesConfig {
+  /**
+   * Container locations from which modules should be resolved and loaded at runtime.
+   */
+  external: RemotesItem | RemotesItems;
+  /**
+   * The name of the share scope shared with this remote.
+   */
+  shareScope?: string;
+}