@module-federation/dts-plugin 0.1.2 → 0.1.4

package/dist/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @module-federation/dts-plugin
 
+## 0.1.4
+
+### Patch Changes
+
+- 8f3a440: fix: detect whether the project is ts
+- Updated dependencies [8f3a440]
+- Updated dependencies [2f697b9]
+  - @module-federation/sdk@0.1.4
+  - @module-federation/managers@0.1.4
+
+## 0.1.3
+
+### Patch Changes
+
+- f926b6c: chore: split types plugins implementation
+  - @module-federation/sdk@0.1.3
+  - @module-federation/managers@0.1.3
+
 ## 0.1.2
 
 ### Patch Changes

package/dist/DTSManagerOptions-c0728719.d.ts

@@ -0,0 +1,29 @@
+import { moduleFederationPlugin } from '@module-federation/sdk';
+
+interface RemoteOptions extends moduleFederationPlugin.DtsRemoteOptions {
+    moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    context?: string;
+    implementation?: string;
+    hostRemoteTypesFolder?: string;
+}
+
+interface HostOptions extends moduleFederationPlugin.DtsHostOptions {
+    moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    context?: string;
+    implementation?: string;
+}
+interface RemoteInfo {
+    name: string;
+    url: string;
+    alias: string;
+    zipUrl?: string;
+    apiTypeUrl?: string;
+}
+
+interface DTSManagerOptions {
+    remote?: RemoteOptions;
+    host?: HostOptions;
+    extraOptions?: Record<string, any>;
+}
+
+export { DTSManagerOptions as D, HostOptions as H, RemoteInfo as R, RemoteOptions as a };

package/dist/DtsWorker-d731dc2b.d.ts

@@ -0,0 +1,97 @@
+import { ChildProcess } from 'child_process';
+import { a as RemoteOptions, D as DTSManagerOptions, R as RemoteInfo, H as HostOptions } from './DTSManagerOptions-c0728719.js';
+import typescript from 'typescript';
+
+declare const retrieveRemoteConfig: (options: RemoteOptions) => {
+    tsConfig: typescript.CompilerOptions;
+    mapComponentsToExpose: Record<string, string>;
+    remoteOptions: Required<RemoteOptions>;
+};
+
+declare const REMOTE_ALIAS_IDENTIFIER = "REMOTE_ALIAS_IDENTIFIER";
+declare const REMOTE_API_TYPES_FILE_NAME = "apis.d.ts";
+declare const HOST_API_TYPES_FILE_NAME = "index.d.ts";
+declare const enum UpdateMode {
+    POSITIVE = "POSITIVE",
+    PASSIVE = "PASSIVE"
+}
+
+interface UpdateTypesOptions {
+    updateMode: UpdateMode;
+    remoteName?: string;
+    remoteTarPath?: string;
+}
+declare class DTSManager {
+    options: DTSManagerOptions;
+    runtimePkgs: string[];
+    remoteAliasMap: Record<string, Required<RemoteInfo>>;
+    loadedRemoteAPIAlias: string[];
+    extraOptions: Record<string, any>;
+    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>;
+    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>[];
+    }>;
+    consumeTypes(): Promise<void>;
+    updateTypes(options: UpdateTypesOptions): Promise<void>;
+}
+
+declare enum RpcGMCallTypes {
+    CALL = "mf_call",
+    RESOLVE = "mf_resolve",
+    REJECT = "mf_reject",
+    EXIT = "mf_exit"
+}
+interface RpcCallMessage {
+    type: RpcGMCallTypes.CALL;
+    id: string;
+    args: unknown[];
+}
+interface RpcResolveMessage {
+    type: RpcGMCallTypes.RESOLVE;
+    id: string;
+    value: unknown;
+}
+interface RpcRejectMessage {
+    type: RpcGMCallTypes.REJECT;
+    id: string;
+    error: unknown;
+}
+interface RpcExitMessage {
+    type: RpcGMCallTypes.EXIT;
+    id: string;
+}
+type RpcMessage = RpcCallMessage | RpcResolveMessage | RpcRejectMessage | RpcExitMessage;
+type RpcMethod = (...args: any[]) => any;
+type RpcRemoteMethod<T extends RpcMethod> = T extends (...args: infer A) => infer R ? R extends Promise<any> ? (...args: A) => R : (...args: A) => Promise<R> : (...args: unknown[]) => Promise<unknown>;
+
+interface RpcWorkerBase {
+    connect(...args: unknown[]): any;
+    terminate(): void;
+    readonly connected: boolean;
+    readonly id: string;
+    readonly process: ChildProcess | undefined;
+}
+type RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorkerBase & RpcRemoteMethod<T>;
+declare function createRpcWorker<T extends RpcMethod>(modulePath: string, data: unknown, memoryLimit?: number, once?: boolean): RpcWorker<T>;
+declare function getRpcWorkerData(): unknown;
+
+type DtsWorkerOptions = DTSManagerOptions;
+declare class DtsWorker {
+    rpcWorker: RpcWorker<RpcMethod>;
+    private _options;
+    private _res;
+    constructor(options: DtsWorkerOptions);
+    removeUnSerializationOptions(): void;
+    get controlledPromise(): ReturnType<DTSManager['generateTypes']>;
+    exit(): void;
+}
+
+export { DTSManager as D, HOST_API_TYPES_FILE_NAME as H, RpcRemoteMethod as R, UpdateMode as U, RpcCallMessage as a, RpcGMCallTypes as b, RpcMessage as c, RpcMethod as d, RpcRejectMessage as e, RpcResolveMessage as f, RpcWorker as g, createRpcWorker as h, getRpcWorkerData as i, DtsWorker as j, REMOTE_ALIAS_IDENTIFIER as k, REMOTE_API_TYPES_FILE_NAME as l, DtsWorkerOptions as m, retrieveRemoteConfig as r };

package/dist/core.d.ts

@@ -0,0 +1,84 @@
+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 { H as HostOptions, R as RemoteInfo, a as RemoteOptions, D as DTSManagerOptions } from './DTSManagerOptions-c0728719.js';
+import typescript from 'typescript';
+import { ChildProcess } from 'child_process';
+import '@module-federation/sdk';
+
+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 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 | undefined;
+    readonly signal?: string | null | undefined;
+    constructor(message: string, code?: string | number | null | undefined, signal?: string | null | undefined);
+}
+
+/**
+ * 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, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveTypesAssetsInfo, retrieveTypesZipPath, index as rpc, validateOptions };