@module-federation/native-federation-typescript 0.1.0 → 0.1.2

package/dist/chunk-VKKLMSMI.mjs

@@ -0,0 +1,179 @@
+import {
+  consumeTypes,
+  generateTypesInChildProcess
+} from "./chunk-QYHGZU7D.mjs";
+import {
+  generateTypes,
+  retrieveTypesAssetsInfo,
+  validateOptions
+} from "./chunk-CF5CH54A.mjs";
+
+// packages/native-federation-typescript/src/index.ts
+import { createUnplugin } from "unplugin";
+import fs from "fs";
+var NativeFederationTypeScriptRemote = createUnplugin(
+  (enhancedOptions) => {
+    const options = "extraOptions" in enhancedOptions ? enhancedOptions.remote : enhancedOptions;
+    const extraOptions = "extraOptions" in enhancedOptions ? enhancedOptions.extraOptions : void 0;
+    validateOptions(options);
+    const isProd = process.env.NODE_ENV === "production";
+    const generateTypesOptions = {
+      remote: options,
+      extraOptions
+    };
+    const getGenerateTypesFn = () => {
+      let fn = generateTypes;
+      let res;
+      if (options.compileInChildProcess) {
+        fn = generateTypesInChildProcess;
+      }
+      if (isProd) {
+        res = fn(generateTypesOptions);
+        return () => res;
+      }
+      return fn;
+    };
+    const generateTypesFn = getGenerateTypesFn();
+    return {
+      name: "native-federation-typescript/remote",
+      rollup: {
+        writeBundle: async () => {
+          await generateTypesFn(generateTypesOptions);
+        }
+      },
+      vite: {
+        buildStart: async () => {
+          if (isProd) {
+            return;
+          }
+          await generateTypesFn(generateTypesOptions);
+        },
+        watchChange: async () => {
+          if (isProd) {
+            return;
+          }
+          await generateTypesFn(generateTypesOptions);
+        },
+        writeBundle: async () => {
+          await generateTypesFn(generateTypesOptions);
+        }
+      },
+      webpack: (compiler) => {
+        compiler.hooks.thisCompilation.tap("generateTypes", (compilation) => {
+          const hookName = "mf:generateTypes";
+          compilation.hooks.processAssets.tapPromise(
+            {
+              name: hookName,
+              stage: (
+                // @ts-expect-error use runtime variable in case peer dep not installed
+                compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+              )
+            },
+            async () => {
+              try {
+                const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(options);
+                if (zipName && compilation.getAsset(zipName)) {
+                  return;
+                }
+                await generateTypesFn(generateTypesOptions);
+                if (zipTypesPath) {
+                  compilation.emitAsset(
+                    zipName,
+                    new compiler.webpack.sources.RawSource(
+                      fs.readFileSync(zipTypesPath),
+                      false
+                    )
+                  );
+                }
+                if (apiTypesPath) {
+                  compilation.emitAsset(
+                    apiFileName,
+                    new compiler.webpack.sources.RawSource(
+                      fs.readFileSync(apiTypesPath),
+                      false
+                    )
+                  );
+                }
+              } catch (err) {
+                console.error(err);
+              }
+            }
+          );
+        });
+      },
+      rspack: (compiler) => {
+        compiler.hooks.thisCompilation.tap("generateTypes", (compilation) => {
+          const hookName = "mf:generateTypes";
+          compilation.hooks.processAssets.tapPromise(
+            {
+              name: hookName,
+              stage: (
+                // @ts-expect-error use runtime variable in case peer dep not installed
+                compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+              )
+            },
+            async () => {
+              try {
+                const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(options);
+                if (zipName && compilation.getAsset(zipName)) {
+                  return;
+                }
+                await generateTypesFn(generateTypesOptions);
+                if (zipTypesPath) {
+                  compilation.emitAsset(
+                    zipName,
+                    new compiler.webpack.sources.RawSource(
+                      fs.readFileSync(zipTypesPath),
+                      false
+                    )
+                  );
+                }
+                if (apiTypesPath) {
+                  compilation.emitAsset(
+                    apiFileName,
+                    new compiler.webpack.sources.RawSource(
+                      fs.readFileSync(apiTypesPath),
+                      false
+                    )
+                  );
+                }
+              } catch (err) {
+                console.error(err);
+              }
+            }
+          );
+        });
+      }
+    };
+  }
+);
+var NativeFederationTypeScriptHost = createUnplugin(
+  (enhancedOptions) => {
+    const options = "extraOptions" in enhancedOptions ? enhancedOptions.host : enhancedOptions;
+    const extraOptions = "extraOptions" in enhancedOptions ? enhancedOptions.extraOptions : void 0;
+    validateOptions(options);
+    const consumeTypesOptions = {
+      host: options,
+      extraOptions
+    };
+    const consumeTypesPromise = consumeTypes(consumeTypesOptions);
+    return {
+      name: "native-federation-typescript/host",
+      async writeBundle() {
+        await consumeTypesPromise;
+      },
+      get vite() {
+        return process.env.NODE_ENV === "production" ? void 0 : {
+          buildStart: async () => {
+            await consumeTypesPromise;
+          }
+        };
+      }
+    };
+  }
+);
+
+export {
+  NativeFederationTypeScriptRemote,
+  NativeFederationTypeScriptHost
+};

package/dist/esbuild.d.mts

@@ -0,0 +1,9 @@
+import { EnhancedRemoteOptions, EnhancedHostOptions } from './index.mjs';
+import 'unplugin';
+import './HostOptions-cf22e0ab.js';
+import '@module-federation/sdk';
+
+declare const NativeFederationTypeScriptRemote: (options: EnhancedRemoteOptions) => undefined;
+declare const NativeFederationTypeScriptHost: (options: EnhancedHostOptions) => undefined;
+
+export { NativeFederationTypeScriptHost, NativeFederationTypeScriptRemote };

package/dist/esbuild.d.ts

@@ -1,6 +1,9 @@
-import { R as RemoteOptions, H as HostOptions } from './RemoteOptions-ce85caac.js';
+import { EnhancedRemoteOptions, EnhancedHostOptions } from './index.js';
+import 'unplugin';
+import './HostOptions-cf22e0ab.js';
+import '@module-federation/sdk';
 
-declare const NativeFederationTypeScriptRemote: (options: RemoteOptions) => undefined;
-declare const NativeFederationTypeScriptHost: (options: HostOptions) => undefined;
+declare const NativeFederationTypeScriptRemote: (options: EnhancedRemoteOptions) => undefined;
+declare const NativeFederationTypeScriptHost: (options: EnhancedHostOptions) => undefined;
 
 export { NativeFederationTypeScriptHost, NativeFederationTypeScriptRemote };

package/dist/esbuild.js

@@ -1 +1,14 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWNKHVVXSjs = require('./chunk-WNKHVVXS.js');var i=_chunkWNKHVVXSjs.a.esbuild,r= exports.NativeFederationTypeScriptHost =_chunkWNKHVVXSjs.b.esbuild;exports.NativeFederationTypeScriptHost = r; exports.NativeFederationTypeScriptRemote = i;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkJLWFNRJLjs = require('./chunk-JLWFNRJL.js');
+require('./chunk-VHQW5BQS.js');
+require('./chunk-2NC7LVYZ.js');
+
+// packages/native-federation-typescript/src/esbuild.ts
+var NativeFederationTypeScriptRemote2 = _chunkJLWFNRJLjs.NativeFederationTypeScriptRemote.esbuild;
+var NativeFederationTypeScriptHost2 = _chunkJLWFNRJLjs.NativeFederationTypeScriptHost.esbuild;
+
+
+
+exports.NativeFederationTypeScriptHost = NativeFederationTypeScriptHost2; exports.NativeFederationTypeScriptRemote = NativeFederationTypeScriptRemote2;

package/dist/esbuild.mjs

@@ -1 +1,14 @@
-import{a as e,b as t}from"./chunk-HJB2AKNY.mjs";var i=e.esbuild,r=t.esbuild;export{r as NativeFederationTypeScriptHost,i as NativeFederationTypeScriptRemote};
+import {
+  NativeFederationTypeScriptHost,
+  NativeFederationTypeScriptRemote
+} from "./chunk-VKKLMSMI.mjs";
+import "./chunk-QYHGZU7D.mjs";
+import "./chunk-CF5CH54A.mjs";
+
+// packages/native-federation-typescript/src/esbuild.ts
+var NativeFederationTypeScriptRemote2 = NativeFederationTypeScriptRemote.esbuild;
+var NativeFederationTypeScriptHost2 = NativeFederationTypeScriptHost.esbuild;
+export {
+  NativeFederationTypeScriptHost2 as NativeFederationTypeScriptHost,
+  NativeFederationTypeScriptRemote2 as NativeFederationTypeScriptRemote
+};

package/dist/helpers.d.mts

@@ -0,0 +1,160 @@
+import typescript from 'typescript';
+import { R as RemoteOptions, H as HostOptions, a as RemoteInfo } from './HostOptions-cf22e0ab.js';
+import { D as DTSManagerOptions } from './DTSManagerOptions-3369791f.js';
+import { ChildProcess } from 'child_process';
+import '@module-federation/sdk';
+
+declare const retrieveRemoteConfig: (options: RemoteOptions) => {
+    tsConfig: typescript.CompilerOptions;
+    mapComponentsToExpose: Record<string, string>;
+    remoteOptions: Required<RemoteOptions>;
+};
+
+declare const retrieveHostConfig: (options: HostOptions) => {
+    hostOptions: Required<HostOptions>;
+    mapRemotesToDownload: Record<string, RemoteInfo>;
+};
+
+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 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 consumeTypes(options: DTSManagerOptions): Promise<void>;
+
+declare function exposeRpc(fn: (...args: any[]) => any): 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 WrapRpcOptions {
+    id: string;
+    once?: boolean;
+}
+declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
+
+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;
+
+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);
+}
+
+type index_RpcCallMessage = RpcCallMessage;
+type index_RpcExitError = RpcExitError;
+declare const index_RpcExitError: typeof RpcExitError;
+type index_RpcGMCallTypes = RpcGMCallTypes;
+declare const index_RpcGMCallTypes: typeof RpcGMCallTypes;
+type index_RpcMessage = RpcMessage;
+type index_RpcMethod = RpcMethod;
+type index_RpcRejectMessage = RpcRejectMessage;
+type index_RpcRemoteMethod<T extends RpcMethod> = RpcRemoteMethod<T>;
+type index_RpcResolveMessage = RpcResolveMessage;
+type index_RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorker<T>;
+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,
+  };
+}
+
+export { DTSManager, DTSManagerOptions, HOST_API_TYPES_FILE_NAME, HostOptions, REMOTE_ALIAS_IDENTIFIER, REMOTE_API_TYPES_FILE_NAME, RemoteOptions, UpdateMode, consumeTypes, generateTypes, generateTypesInChildProcess, getDTSManagerConstructor, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveRemoteConfig, retrieveTypesAssetsInfo, retrieveTypesZipPath, index as rpc, validateOptions };

package/dist/helpers.d.ts

@@ -0,0 +1,160 @@
+import typescript from 'typescript';
+import { R as RemoteOptions, H as HostOptions, a as RemoteInfo } from './HostOptions-cf22e0ab.js';
+import { D as DTSManagerOptions } from './DTSManagerOptions-3369791f.js';
+import { ChildProcess } from 'child_process';
+import '@module-federation/sdk';
+
+declare const retrieveRemoteConfig: (options: RemoteOptions) => {
+    tsConfig: typescript.CompilerOptions;
+    mapComponentsToExpose: Record<string, string>;
+    remoteOptions: Required<RemoteOptions>;
+};
+
+declare const retrieveHostConfig: (options: HostOptions) => {
+    hostOptions: Required<HostOptions>;
+    mapRemotesToDownload: Record<string, RemoteInfo>;
+};
+
+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 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 consumeTypes(options: DTSManagerOptions): Promise<void>;
+
+declare function exposeRpc(fn: (...args: any[]) => any): 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 WrapRpcOptions {
+    id: string;
+    once?: boolean;
+}
+declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
+
+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;
+
+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);
+}
+
+type index_RpcCallMessage = RpcCallMessage;
+type index_RpcExitError = RpcExitError;
+declare const index_RpcExitError: typeof RpcExitError;
+type index_RpcGMCallTypes = RpcGMCallTypes;
+declare const index_RpcGMCallTypes: typeof RpcGMCallTypes;
+type index_RpcMessage = RpcMessage;
+type index_RpcMethod = RpcMethod;
+type index_RpcRejectMessage = RpcRejectMessage;
+type index_RpcRemoteMethod<T extends RpcMethod> = RpcRemoteMethod<T>;
+type index_RpcResolveMessage = RpcResolveMessage;
+type index_RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorker<T>;
+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,
+  };
+}
+
+export { DTSManager, DTSManagerOptions, HOST_API_TYPES_FILE_NAME, HostOptions, REMOTE_ALIAS_IDENTIFIER, REMOTE_API_TYPES_FILE_NAME, RemoteOptions, UpdateMode, consumeTypes, generateTypes, generateTypesInChildProcess, getDTSManagerConstructor, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveRemoteConfig, retrieveTypesAssetsInfo, retrieveTypesZipPath, index as rpc, validateOptions };

package/dist/helpers.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkVHQW5BQSjs = require('./chunk-VHQW5BQS.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2NC7LVYZjs = require('./chunk-2NC7LVYZ.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DTSManager = _chunk2NC7LVYZjs.DTSManager; exports.HOST_API_TYPES_FILE_NAME = _chunk2NC7LVYZjs.HOST_API_TYPES_FILE_NAME; exports.REMOTE_ALIAS_IDENTIFIER = _chunk2NC7LVYZjs.REMOTE_ALIAS_IDENTIFIER; exports.REMOTE_API_TYPES_FILE_NAME = _chunk2NC7LVYZjs.REMOTE_API_TYPES_FILE_NAME; exports.UpdateMode = _chunk2NC7LVYZjs.UpdateMode; exports.consumeTypes = _chunkVHQW5BQSjs.consumeTypes; exports.generateTypes = _chunk2NC7LVYZjs.generateTypes; exports.generateTypesInChildProcess = _chunkVHQW5BQSjs.generateTypesInChildProcess; exports.getDTSManagerConstructor = _chunk2NC7LVYZjs.getDTSManagerConstructor; exports.retrieveHostConfig = _chunk2NC7LVYZjs.retrieveHostConfig; exports.retrieveMfTypesPath = _chunk2NC7LVYZjs.retrieveMfTypesPath; exports.retrieveOriginalOutDir = _chunk2NC7LVYZjs.retrieveOriginalOutDir; exports.retrieveRemoteConfig = _chunk2NC7LVYZjs.retrieveRemoteConfig; exports.retrieveTypesAssetsInfo = _chunk2NC7LVYZjs.retrieveTypesAssetsInfo; exports.retrieveTypesZipPath = _chunk2NC7LVYZjs.retrieveTypesZipPath; exports.rpc = _chunkVHQW5BQSjs.rpc_exports; exports.validateOptions = _chunk2NC7LVYZjs.validateOptions;

package/dist/helpers.mjs

@@ -0,0 +1,40 @@
+import {
+  consumeTypes,
+  generateTypesInChildProcess,
+  rpc_exports
+} from "./chunk-QYHGZU7D.mjs";
+import {
+  DTSManager,
+  HOST_API_TYPES_FILE_NAME,
+  REMOTE_ALIAS_IDENTIFIER,
+  REMOTE_API_TYPES_FILE_NAME,
+  UpdateMode,
+  generateTypes,
+  getDTSManagerConstructor,
+  retrieveHostConfig,
+  retrieveMfTypesPath,
+  retrieveOriginalOutDir,
+  retrieveRemoteConfig,
+  retrieveTypesAssetsInfo,
+  retrieveTypesZipPath,
+  validateOptions
+} from "./chunk-CF5CH54A.mjs";
+export {
+  DTSManager,
+  HOST_API_TYPES_FILE_NAME,
+  REMOTE_ALIAS_IDENTIFIER,
+  REMOTE_API_TYPES_FILE_NAME,
+  UpdateMode,
+  consumeTypes,
+  generateTypes,
+  generateTypesInChildProcess,
+  getDTSManagerConstructor,
+  retrieveHostConfig,
+  retrieveMfTypesPath,
+  retrieveOriginalOutDir,
+  retrieveRemoteConfig,
+  retrieveTypesAssetsInfo,
+  retrieveTypesZipPath,
+  rpc_exports as rpc,
+  validateOptions
+};

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import * as unplugin from 'unplugin';
+import { R as RemoteOptions, H as HostOptions } from './HostOptions-cf22e0ab.js';
+import '@module-federation/sdk';
+
+type EnhancedRemoteOptions = {
+    remote: RemoteOptions;
+    extraOptions: Record<string, any>;
+} | RemoteOptions;
+type EnhancedHostOptions = {
+    host: HostOptions;
+    extraOptions: Record<string, any>;
+} | HostOptions;
+declare const NativeFederationTypeScriptRemote: unplugin.UnpluginInstance<EnhancedRemoteOptions, boolean>;
+declare const NativeFederationTypeScriptHost: unplugin.UnpluginInstance<EnhancedHostOptions, boolean>;
+
+export { EnhancedHostOptions, EnhancedRemoteOptions, NativeFederationTypeScriptHost, NativeFederationTypeScriptRemote };

package/dist/index.d.ts

@@ -1,7 +1,16 @@
 import * as unplugin from 'unplugin';
-import { R as RemoteOptions, H as HostOptions } from './RemoteOptions-ce85caac.js';
+import { R as RemoteOptions, H as HostOptions } from './HostOptions-cf22e0ab.js';
+import '@module-federation/sdk';
 
-declare const NativeFederationTypeScriptRemote: unplugin.UnpluginInstance<RemoteOptions, boolean>;
-declare const NativeFederationTypeScriptHost: unplugin.UnpluginInstance<HostOptions, boolean>;
+type EnhancedRemoteOptions = {
+    remote: RemoteOptions;
+    extraOptions: Record<string, any>;
+} | RemoteOptions;
+type EnhancedHostOptions = {
+    host: HostOptions;
+    extraOptions: Record<string, any>;
+} | HostOptions;
+declare const NativeFederationTypeScriptRemote: unplugin.UnpluginInstance<EnhancedRemoteOptions, boolean>;
+declare const NativeFederationTypeScriptHost: unplugin.UnpluginInstance<EnhancedHostOptions, boolean>;
 
-export { NativeFederationTypeScriptHost, NativeFederationTypeScriptRemote };
+export { EnhancedHostOptions, EnhancedRemoteOptions, NativeFederationTypeScriptHost, NativeFederationTypeScriptRemote };