@module-federation/dts-plugin 0.1.19 → 0.1.21

package/dist/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @module-federation/dts-plugin
 
+## 0.1.21
+
+### Patch Changes
+
+- a50c459: fix: use ipv4 first while load local remote
+- 88900ad: fix: support decode encode remote name
+- 4cddb8a: fix: no delete exist types if fetch new types failed
+- 6ee10aa: fix: replace sourceEntry with index if the value is '.'
+- 1e93c5e: fix: use userOptions.typesFolder first
+- Updated dependencies [88900ad]
+  - @module-federation/sdk@0.1.21
+  - @module-federation/managers@0.1.21
+  - @module-federation/third-party-dts-extractor@0.1.21
+
+## 0.1.20
+
+### Patch Changes
+
+- 685c607: feat: support dynamic remote type hints
+- 34f9498: dts-plugin can now support remotes using relative path references: 'app@/mf-manifest.json'
+- Updated dependencies [685c607]
+- Updated dependencies [e8e0969]
+- Updated dependencies [349c381]
+  - @module-federation/third-party-dts-extractor@0.1.20
+  - @module-federation/sdk@0.1.20
+  - @module-federation/managers@0.1.20
+
 ## 0.1.19
 
 ### Patch Changes

package/dist/{DtsWorker-d731dc2b.d.ts → DtsWorker-7113d2b0.d.ts}

@@ -20,24 +20,27 @@ interface UpdateTypesOptions {
     updateMode: UpdateMode;
     remoteName?: string;
     remoteTarPath?: string;
+    remoteInfo?: RemoteInfo;
+    once?: boolean;
 }
 declare class DTSManager {
     options: DTSManagerOptions;
     runtimePkgs: string[];
     remoteAliasMap: Record<string, Required<RemoteInfo>>;
-    loadedRemoteAPIAlias: string[];
+    loadedRemoteAPIAlias: Set<string>;
     extraOptions: Record<string, any>;
+    updatedRemoteInfos: Record<string, Required<RemoteInfo>>;
     constructor(options: DTSManagerOptions);
     generateAPITypes(mapComponentsToExpose: Record<string, string>): string;
     extractRemoteTypes(options: ReturnType<typeof retrieveRemoteConfig>): Promise<void>;
     generateTypes(): Promise<void>;
     requestRemoteManifest(remoteInfo: RemoteInfo): Promise<Required<RemoteInfo>>;
-    consumeTargetRemotes(hostOptions: Required<HostOptions>, remoteInfo: Required<RemoteInfo>): Promise<[string, string] | undefined>;
+    consumeTargetRemotes(hostOptions: Required<HostOptions>, remoteInfo: Required<RemoteInfo>): Promise<[string, string]>;
     downloadAPITypes(remoteInfo: Required<RemoteInfo>, destinationPath: string): Promise<void>;
     consumeAPITypes(hostOptions: Required<HostOptions>): void;
     consumeArchiveTypes(options: HostOptions): Promise<{
         hostOptions: Required<HostOptions>;
-        downloadPromisesResult: PromiseSettledResult<[string, string] | undefined>[];
+        downloadPromisesResult: PromiseSettledResult<[string, string]>[];
     }>;
     consumeTypes(): Promise<void>;
     updateTypes(options: UpdateTypesOptions): Promise<void>;

package/dist/core.d.mts

@@ -0,0 +1,85 @@
+import { D as DTSManager, R as RpcRemoteMethod, a as RpcCallMessage, b as RpcGMCallTypes, c as RpcMessage, d as RpcMethod, e as RpcRejectMessage, f as RpcResolveMessage, g as RpcWorker, h as createRpcWorker, i as getRpcWorkerData } from './DtsWorker-7113d2b0.js';
+export { j as DtsWorker, H as HOST_API_TYPES_FILE_NAME, k as REMOTE_ALIAS_IDENTIFIER, l as REMOTE_API_TYPES_FILE_NAME, U as UpdateMode, r as retrieveRemoteConfig } from './DtsWorker-7113d2b0.js';
+import { H as HostOptions, R as RemoteInfo, a as RemoteOptions, D as DTSManagerOptions } from './DTSManagerOptions-c0728719.js';
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import typescript from 'typescript';
+import { ChildProcess } from 'child_process';
+
+declare const retrieveHostConfig: (options: HostOptions) => {
+    hostOptions: Required<HostOptions>;
+    mapRemotesToDownload: Record<string, RemoteInfo>;
+};
+
+declare function getDTSManagerConstructor(implementation?: string): typeof DTSManager;
+declare const validateOptions: (options: HostOptions) => void;
+declare function retrieveTypesAssetsInfo(options: RemoteOptions): {
+    apiTypesPath: string;
+    zipTypesPath: string;
+    zipName: string;
+    apiFileName: string;
+};
+declare const isTSProject: (dtsOptions: moduleFederationPlugin.ModuleFederationPluginOptions['dts'], context?: string) => boolean;
+
+declare const retrieveMfTypesPath: (tsConfig: typescript.CompilerOptions, remoteOptions: Required<RemoteOptions>) => string;
+declare const retrieveOriginalOutDir: (tsConfig: typescript.CompilerOptions, remoteOptions: Required<RemoteOptions>) => string;
+
+declare const retrieveTypesZipPath: (mfTypesPath: string, remoteOptions: Required<RemoteOptions>) => string;
+
+declare function generateTypes(options: DTSManagerOptions): Promise<void>;
+
+declare function generateTypesInChildProcess(options: DTSManagerOptions): Promise<void>;
+
+declare function exposeRpc(fn: (...args: any[]) => any): void;
+
+interface WrapRpcOptions {
+    id: string;
+    once?: boolean;
+}
+declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
+
+declare class RpcExitError extends Error {
+    readonly code?: string | number | null;
+    readonly signal?: string | null;
+    constructor(message: string, code?: string | number | null, signal?: string | null);
+}
+
+/**
+ * forked from https://github.com/TypeStrong/fork-ts-checker-webpack-plugin
+ * license at https://github.com/TypeStrong/fork-ts-checker-webpack-plugin/blob/main/LICENSE
+ */
+
+declare const index_RpcCallMessage: typeof RpcCallMessage;
+type index_RpcExitError = RpcExitError;
+declare const index_RpcExitError: typeof RpcExitError;
+declare const index_RpcGMCallTypes: typeof RpcGMCallTypes;
+declare const index_RpcMessage: typeof RpcMessage;
+declare const index_RpcMethod: typeof RpcMethod;
+declare const index_RpcRejectMessage: typeof RpcRejectMessage;
+declare const index_RpcRemoteMethod: typeof RpcRemoteMethod;
+declare const index_RpcResolveMessage: typeof RpcResolveMessage;
+declare const index_RpcWorker: typeof RpcWorker;
+declare const index_createRpcWorker: typeof createRpcWorker;
+declare const index_exposeRpc: typeof exposeRpc;
+declare const index_getRpcWorkerData: typeof getRpcWorkerData;
+declare const index_wrapRpc: typeof wrapRpc;
+declare namespace index {
+  export {
+    index_RpcCallMessage as RpcCallMessage,
+    index_RpcExitError as RpcExitError,
+    index_RpcGMCallTypes as RpcGMCallTypes,
+    index_RpcMessage as RpcMessage,
+    index_RpcMethod as RpcMethod,
+    index_RpcRejectMessage as RpcRejectMessage,
+    index_RpcRemoteMethod as RpcRemoteMethod,
+    index_RpcResolveMessage as RpcResolveMessage,
+    index_RpcWorker as RpcWorker,
+    index_createRpcWorker as createRpcWorker,
+    index_exposeRpc as exposeRpc,
+    index_getRpcWorkerData as getRpcWorkerData,
+    index_wrapRpc as wrapRpc,
+  };
+}
+
+declare function consumeTypes(options: DTSManagerOptions): Promise<void>;
+
+export { DTSManager, DTSManagerOptions, HostOptions, RemoteOptions, consumeTypes, generateTypes, generateTypesInChildProcess, getDTSManagerConstructor, isTSProject, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveTypesAssetsInfo, retrieveTypesZipPath, index as rpc, validateOptions };

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { D as DTSManager, R as RpcRemoteMethod, a as RpcCallMessage, b as RpcGMCallTypes, c as RpcMessage, d as RpcMethod, e as RpcRejectMessage, f as RpcResolveMessage, g as RpcWorker, h as createRpcWorker, i as getRpcWorkerData } from './DtsWorker-d731dc2b.js';
-export { j as DtsWorker, H as HOST_API_TYPES_FILE_NAME, k as REMOTE_ALIAS_IDENTIFIER, l as REMOTE_API_TYPES_FILE_NAME, U as UpdateMode, r as retrieveRemoteConfig } from './DtsWorker-d731dc2b.js';
+import { D as DTSManager, R as RpcRemoteMethod, a as RpcCallMessage, b as RpcGMCallTypes, c as RpcMessage, d as RpcMethod, e as RpcRejectMessage, f as RpcResolveMessage, g as RpcWorker, h as createRpcWorker, i as getRpcWorkerData } from './DtsWorker-7113d2b0.js';
+export { j as DtsWorker, H as HOST_API_TYPES_FILE_NAME, k as REMOTE_ALIAS_IDENTIFIER, l as REMOTE_API_TYPES_FILE_NAME, U as UpdateMode, r as retrieveRemoteConfig } from './DtsWorker-7113d2b0.js';
 import { H as HostOptions, R as RemoteInfo, a as RemoteOptions, D as DTSManagerOptions } from './DTSManagerOptions-c0728719.js';
 import { moduleFederationPlugin } from '@module-federation/sdk';
 import typescript from 'typescript';
@@ -38,9 +38,9 @@ interface WrapRpcOptions {
 declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
 
 declare class RpcExitError extends Error {
-    readonly code?: string | number | null | undefined;
-    readonly signal?: string | null | undefined;
-    constructor(message: string, code?: string | number | null | undefined, signal?: string | null | undefined);
+    readonly code?: string | number | null;
+    readonly signal?: string | null;
+    constructor(message: string, code?: string | number | null, signal?: string | null);
 }
 
 /**