@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/esm-node/ssr-runtime/devPlugin.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload";
+import { flushDataFetch } from "../utils";
+const mfSSRDevPlugin = () => ({
+  name: "@module-federation/modern-js",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      if (typeof window !== "undefined") {
+        return;
+      }
+      globalThis.shouldUpdate = false;
+      const nodeUtils = await import("@module-federation/node/utils");
+      const shouldUpdate = await nodeUtils.revalidate();
+      console.log("shouldUpdate: ", shouldUpdate);
+      if (shouldUpdate) {
+        console.log("should RELOAD", shouldUpdate);
+        await nodeUtils.flushChunks();
+        flushDataFetch();
+        globalThis.shouldUpdate = true;
+      }
+    });
+    api.wrapRoot((App) => {
+      const AppWrapper = (props) => /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          /* @__PURE__ */ _jsx(SSRLiveReload, {}),
+          /* @__PURE__ */ _jsx(App, {
+            ...props
+          })
+        ]
+      });
+      return AppWrapper;
+    });
+  }
+});
+export {
+  mfSSRDevPlugin
+};

package/dist/esm-node/ssr-runtime/downgrade.js

@@ -0,0 +1,88 @@
+import { DATA_FETCH_QUERY, DOWNGRADE_KEY } from "../constant";
+import { MF_DATA_FETCH_STATUS, MF_DATA_FETCH_TYPE } from "../constant";
+import { getDataFetchMap } from "../utils";
+function getDowngradeTag() {
+  return globalThis[DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  const dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach((key) => {
+    callDowngrade(key);
+  });
+}
+async function callDowngrade(id, params, remoteInfo) {
+  const dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  const mfDataFetch = dataFetchMap[id];
+  if ((mfDataFetch === null || mfDataFetch === void 0 ? void 0 : mfDataFetch[2]) === MF_DATA_FETCH_STATUS.AWAIT) {
+    mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADING;
+    let promise, res, rej;
+    if (mfDataFetch[1]) {
+      promise = mfDataFetch[1][0];
+      res = mfDataFetch[1][1];
+      rej = mfDataFetch[1][2];
+    } else {
+      promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      mfDataFetch[1] = [
+        promise,
+        res,
+        rej
+      ];
+    }
+    const dataFetchType = mfDataFetch[0][1];
+    if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_CLIENT) {
+      try {
+        mfDataFetch[0][0]().then((getDataFetchFn) => {
+          return getDataFetchFn({
+            ...params,
+            isDowngrade: true
+          }).then((data) => {
+            mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+            res(data);
+          });
+        });
+      } catch (e) {
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    } else if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_SERVER) {
+      try {
+        const currentUrl = new URL(window.location.href);
+        currentUrl.searchParams.set(DATA_FETCH_QUERY, encodeURIComponent(id));
+        if (params) {
+          currentUrl.searchParams.set("params", encodeURIComponent(JSON.stringify(params)));
+        }
+        if (remoteInfo) {
+          currentUrl.searchParams.set("remoteInfo", encodeURIComponent(JSON.stringify(remoteInfo)));
+        }
+        const fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+        if (fetchServerQuery && typeof fetchServerQuery === "object") {
+          Object.keys(fetchServerQuery).forEach((key) => {
+            currentUrl.searchParams.set(key, JSON.stringify(fetchServerQuery[key]));
+          });
+        }
+        const fetchUrl = currentUrl.toString();
+        const data = await fetch(fetchUrl).then((res2) => res2.json());
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+        res(data);
+      } catch (e) {
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    }
+    return promise;
+  }
+}
+export {
+  callAllDowngrade,
+  callDowngrade,
+  getDowngradeTag
+};

package/dist/esm-node/ssr-runtime/injectDataFetchFunctionPlugin.js

@@ -0,0 +1,101 @@
+import { DATA_FETCH_FUNCTION, DOWNGRADE_KEY, FS_HREF, MF_DATA_FETCH_STATUS, MF_DATA_FETCH_TYPE } from "../constant";
+import logger from "../logger";
+import { getDataFetchMap, getDataFetchItem, initDataFetchMap } from "../utils";
+import { callAllDowngrade, callDowngrade, getDowngradeTag } from "./downgrade";
+function setSSREnv({ fetchServerQuery }) {
+  globalThis.FEDERATION_SSR = true;
+  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
+}
+const injectDataFetchFunctionPlugin = ({ fetchServerQuery }) => ({
+  name: "@module-federation/inject-data-fetch-function-plugin",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      var _globalThis, _DATA_FETCH_FUNCTION;
+      setSSREnv({
+        fetchServerQuery
+      });
+      if (typeof window === "undefined") {
+        return;
+      }
+      const dataFetchFunction = async function(options) {
+        const [id, data, downgrade] = options;
+        logger.debug("==========call data fetch function!");
+        if (data) {
+          if (!id) {
+            throw new Error("id is required!");
+          }
+          if (!getDataFetchMap()) {
+            initDataFetchMap();
+          }
+          const dataFetchItem = getDataFetchItem(id);
+          if (dataFetchItem) {
+            var _dataFetchItem__, _dataFetchItem_;
+            (_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : (_dataFetchItem__ = _dataFetchItem_[1]) === null || _dataFetchItem__ === void 0 ? void 0 : _dataFetchItem__.call(_dataFetchItem_, data);
+            dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
+            return;
+          }
+          if (!dataFetchItem) {
+            const dataFetchMap = getDataFetchMap();
+            let res;
+            let rej;
+            const p = new Promise((resolve, reject) => {
+              res = resolve;
+              rej = reject;
+            });
+            dataFetchMap[id] = [
+              [
+                async () => async () => {
+                  return "";
+                },
+                MF_DATA_FETCH_TYPE.FETCH_SERVER
+              ],
+              [
+                p,
+                res,
+                rej
+              ],
+              MF_DATA_FETCH_STATUS.LOADED
+            ];
+            res(data);
+            return;
+          }
+        }
+        if (downgrade) {
+          const mfDowngrade2 = getDowngradeTag();
+          if (!mfDowngrade2) {
+            globalThis[DOWNGRADE_KEY] = id ? [
+              id
+            ] : true;
+          } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+            mfDowngrade2.push(id);
+          }
+        }
+        const mfDowngrade = getDowngradeTag();
+        if (typeof mfDowngrade === "boolean") {
+          return callAllDowngrade();
+        }
+        if (Array.isArray(mfDowngrade)) {
+          if (!id) {
+            globalThis[DOWNGRADE_KEY] = true;
+            return callAllDowngrade();
+          }
+          if (!mfDowngrade.includes(id)) {
+            mfDowngrade.push(id);
+          }
+          return callDowngrade(id);
+        }
+      };
+      globalThis[FS_HREF] = window.location.href;
+      (_globalThis = globalThis)[_DATA_FETCH_FUNCTION = DATA_FETCH_FUNCTION] || (_globalThis[_DATA_FETCH_FUNCTION] = []);
+      const dataFetch = globalThis[DATA_FETCH_FUNCTION];
+      await Promise.all(dataFetch.map(async (options) => {
+        await dataFetchFunction(options);
+      }));
+      dataFetch.push = dataFetchFunction;
+    });
+  }
+});
+export {
+  injectDataFetchFunctionPlugin,
+  setSSREnv
+};

package/dist/esm-node/utils/dataFetch.js

@@ -0,0 +1,166 @@
+import { isBrowserEnv, composeKeyWithSeparator } from "@module-federation/sdk";
+import { isCSROnly } from "../utils";
+import logger from "../logger";
+import { callDowngrade, getDowngradeTag } from "../ssr-runtime/downgrade";
+import { DOWNGRADE_KEY, MF_DATA_FETCH_STATUS, WRAP_DATA_FETCH_ID_IDENTIFIER } from "../constant";
+import { DATA_FETCH_CLIENT_SUFFIX, DATA_FETCH_IDENTIFIER } from "@module-federation/rsbuild-plugin/constant";
+const getDataFetchInfo = ({ name, alias, id, remoteSnapshot }) => {
+  if (!remoteSnapshot) {
+    return;
+  }
+  if (!("modules" in remoteSnapshot)) {
+    return;
+  }
+  const regex = new RegExp(`^${name}(/[^/].*|)$`);
+  const nameOrAlias = regex.test(id) ? name : alias || name;
+  const expose = id.replace(nameOrAlias, "");
+  let dataFetchName = "";
+  let dataFetchId = "";
+  if (expose.startsWith("/")) {
+    dataFetchName = `${expose.slice(1)}.${DATA_FETCH_IDENTIFIER}`;
+    dataFetchId = `${id}.${DATA_FETCH_IDENTIFIER}`;
+  } else if (expose === "") {
+    dataFetchName = DATA_FETCH_IDENTIFIER;
+    dataFetchId = `${id}/${DATA_FETCH_IDENTIFIER}`;
+  } else {
+    return;
+  }
+  if (!dataFetchName || !dataFetchId) {
+    return;
+  }
+  if (!remoteSnapshot.modules.find((module) => module.moduleName === dataFetchName)) {
+    return;
+  }
+  return {
+    dataFetchName,
+    dataFetchId
+  };
+};
+function initDataFetchMap() {
+  var _globalThis;
+  (_globalThis = globalThis).__MF_DATA_FETCH_MAP__ || (_globalThis.__MF_DATA_FETCH_MAP__ = {});
+}
+function getDataFetchItem(id) {
+  var _globalThis___MF_DATA_FETCH_MAP__;
+  return (_globalThis___MF_DATA_FETCH_MAP__ = globalThis.__MF_DATA_FETCH_MAP__) === null || _globalThis___MF_DATA_FETCH_MAP__ === void 0 ? void 0 : _globalThis___MF_DATA_FETCH_MAP__[id];
+}
+function getDataFetchMap() {
+  return globalThis.__MF_DATA_FETCH_MAP__;
+}
+const flushDataFetch = () => {
+  globalThis.__MF_DATA_FETCH_MAP__ = {};
+  globalThis[DOWNGRADE_KEY] = void 0;
+};
+function setDataFetchItemLoadedStatus(id) {
+  const dataFetchItem = getDataFetchItem(id);
+  if (!dataFetchItem) {
+    return;
+  }
+  dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
+}
+const wrapDataFetchId = (id) => {
+  return `${WRAP_DATA_FETCH_ID_IDENTIFIER}${id}${WRAP_DATA_FETCH_ID_IDENTIFIER}`;
+};
+const getDataFetchIdWithErrorMsgs = (errMsgs) => {
+  const firstIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER);
+  if (firstIdentifierIndex === -1) {
+    return void 0;
+  }
+  const secondIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER, firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length);
+  if (secondIdentifierIndex === -1) {
+    return void 0;
+  }
+  return errMsgs.substring(firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length, secondIdentifierIndex);
+};
+async function fetchData(id, params, remoteInfo) {
+  const callFetchData = async () => {
+    const item = getDataFetchItem(id);
+    if (!item) {
+      return;
+    }
+    const [fetchDataFnArr, ..._rest] = item;
+    const fetchDataFn = await fetchDataFnArr[2];
+    if (!fetchDataFn) {
+      return;
+    }
+    return fetchDataFn(params);
+  };
+  if (isBrowserEnv()) {
+    var _dataFetchItem_;
+    const dataFetchItem = getDataFetchItem(id);
+    if (!dataFetchItem) {
+      throw new Error(`dataFetchItem not found, id: ${id}`);
+    }
+    if ((_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : _dataFetchItem_[0]) {
+      return dataFetchItem[1][0];
+    }
+    if (isCSROnly()) {
+      logger.debug("==========csr only!");
+      return callFetchData();
+    }
+    if (remoteInfo) {
+      return callDowngrade(id, params, remoteInfo);
+    }
+    const mfDowngrade = getDowngradeTag();
+    if (mfDowngrade) {
+      if (typeof mfDowngrade === "boolean") {
+        return callDowngrade(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+      if (mfDowngrade.includes(id)) {
+        return callDowngrade(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+    }
+    let res;
+    let rej;
+    const p = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    dataFetchItem[1] = [
+      p,
+      res,
+      rej
+    ];
+    dataFetchItem[2] = MF_DATA_FETCH_STATUS.AWAIT;
+    return dataFetchItem[1][0];
+  }
+  return callFetchData();
+}
+function getDataFetchMapKey(dataFetchInfo, hostInfo) {
+  if (!dataFetchInfo || !hostInfo) {
+    return;
+  }
+  const { dataFetchId } = dataFetchInfo;
+  return composeKeyWithSeparator(dataFetchId, hostInfo.name, hostInfo.version);
+}
+async function loadDataFetchModule(instance, id) {
+  return instance.loadRemote(id).then((m) => {
+    if (m && typeof m === "object" && "fetchData" in m && typeof m.fetchData === "function") {
+      return m.fetchData;
+    }
+    throw new Error(`fetchData not found in remote ${id}, ${JSON.stringify(m)}`);
+  });
+}
+function isDataLoaderExpose(exposeKey) {
+  return exposeKey.endsWith(DATA_FETCH_IDENTIFIER) || exposeKey.endsWith(DATA_FETCH_CLIENT_SUFFIX);
+}
+export {
+  fetchData,
+  flushDataFetch,
+  getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo,
+  getDataFetchItem,
+  getDataFetchMap,
+  getDataFetchMapKey,
+  initDataFetchMap,
+  isDataLoaderExpose,
+  loadDataFetchModule,
+  setDataFetchItemLoadedStatus,
+  wrapDataFetchId
+};

package/dist/esm-node/utils/index.js

@@ -0,0 +1,27 @@
+function getLoadedRemoteInfos(id, instance) {
+  if (!instance) {
+    return;
+  }
+  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
+  if (!name) {
+    return;
+  }
+  const module = instance.moduleCache.get(name);
+  if (!module) {
+    return;
+  }
+  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(module.remoteInfo);
+  return {
+    ...module.remoteInfo,
+    snapshot: remoteSnapshot,
+    expose
+  };
+}
+function isCSROnly() {
+  return window._SSR_DATA === void 0;
+}
+export * from "./dataFetch";
+export {
+  getLoadedRemoteInfos,
+  isCSROnly
+};

package/dist/types/cli/configPlugin.d.ts

@@ -0,0 +1,21 @@
+import { isWebTarget, skipByTarget } from './utils';
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import { PluginOptions } from '../types';
+import type { InternalModernPluginOptions } from '../types';
+import type { AppTools, webpack, UserConfig, Rspack, CliPluginFuture } from '@modern-js/app-tools';
+import type { BundlerChainConfig } from '../interfaces/bundler';
+export type ConfigType<T> = T extends 'webpack' ? webpack.Configuration : T extends 'rspack' ? Rspack.Configuration : never;
+export declare function setEnv(enableSSR: boolean): void;
+export declare const getMFConfig: (userConfig: PluginOptions) => Promise<moduleFederationPlugin.ModuleFederationPluginOptions>;
+export declare const patchMFConfig: (mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions, isServer: boolean, remoteIpStrategy?: "ipv4" | "inherit", enableSSR?: boolean) => moduleFederationPlugin.ModuleFederationPluginOptions;
+export declare function addMyTypes2Ignored(chain: BundlerChainConfig, mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions): void;
+export declare function patchBundlerConfig(options: {
+    chain: BundlerChainConfig;
+    isServer: boolean;
+    modernjsConfig: UserConfig<AppTools>;
+    mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    enableSSR: boolean;
+}): void;
+export declare const moduleFederationConfigPlugin: (userConfig: InternalModernPluginOptions) => CliPluginFuture<AppTools>;
+export default moduleFederationConfigPlugin;
+export { isWebTarget, skipByTarget };

package/dist/types/cli/configPlugin.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/index.d.ts

@@ -0,0 +1,6 @@
+import type { CliPluginFuture, AppTools } from '@modern-js/app-tools';
+import type { PluginOptions } from '../types';
+export declare const moduleFederationPlugin: (userConfig?: PluginOptions) => CliPluginFuture<AppTools>;
+export default moduleFederationPlugin;
+export { createModuleFederationConfig } from '@module-federation/enhanced';
+export type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';

package/dist/types/cli/mfRuntimePlugins/auto-fetch-data.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const autoFetchData: () => FederationRuntimePlugin;
+export default autoFetchData;

package/dist/types/cli/mfRuntimePlugins/inject-node-fetch.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const injectNodeFetchPlugin: () => FederationRuntimePlugin;
+export default injectNodeFetchPlugin;

package/dist/types/cli/mfRuntimePlugins/resolve-entry-ipv4.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const resolveEntryIpv4Plugin: () => FederationRuntimePlugin;
+export default resolveEntryIpv4Plugin;

package/dist/types/cli/mfRuntimePlugins/shared-strategy.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const sharedStrategy: () => FederationRuntimePlugin;
+export default sharedStrategy;

package/dist/types/cli/server/data-fetch-server-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { ServerPlugin } from '@modern-js/server-runtime';
+declare const dataFetchServePlugin: () => ServerPlugin;
+export default dataFetchServePlugin;

package/dist/types/cli/ssrPlugin.d.ts

@@ -0,0 +1,6 @@
+import type { CliPluginFuture, AppTools } from '@modern-js/app-tools';
+import type { InternalModernPluginOptions } from '../types';
+export declare function setEnv(): void;
+export declare const CHAIN_MF_PLUGIN_ID = "plugin-module-federation-server";
+export declare const moduleFederationSSRPlugin: (pluginOptions: Required<InternalModernPluginOptions>) => CliPluginFuture<AppTools>;
+export default moduleFederationSSRPlugin;

package/dist/types/cli/utils.d.ts

@@ -0,0 +1,6 @@
+import type { webpack, Rspack } from '@modern-js/app-tools';
+export type ConfigType<T> = T extends 'webpack' ? webpack.Configuration : T extends 'rspack' ? Rspack.Configuration : never;
+export declare const getIPV4: () => string;
+export declare const isWebTarget: (target: string[] | string) => boolean;
+export declare const skipByTarget: (target: string[] | string) => boolean;
+export declare function isDev(): boolean;

package/dist/types/constant.d.ts

@@ -0,0 +1,25 @@
+export declare const LOCALHOST = "localhost";
+export declare const PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
+export declare const DATA_FETCH_QUERY = "x-mf-data-fetch";
+export declare const DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
+export declare const LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
+export declare const DOWNGRADE_KEY = "_mfSSRDowngrade";
+export declare const DATA_FETCH_MAP_KEY = "__MF_DATA_FETCH_MAP__";
+export declare const DATA_FETCH_FUNCTION = "_mfDataFetch";
+export declare const FS_HREF = "_mfFSHref";
+export declare const ERROR_TYPE: {
+    DATA_FETCH: number;
+    LOAD_REMOTE: number;
+    UNKNOWN: number;
+};
+export declare const WRAP_DATA_FETCH_ID_IDENTIFIER = "wrap_dfip_identifier";
+export declare const enum MF_DATA_FETCH_TYPE {
+    FETCH_SERVER = 1,
+    FETCH_CLIENT = 2
+}
+export declare const enum MF_DATA_FETCH_STATUS {
+    LOADED = 1,
+    LOADING = 2,
+    AWAIT = 0,
+    ERROR = 3
+}

package/dist/types/interfaces/bundler.d.ts

@@ -0,0 +1,18 @@
+import type { AppTools, Bundler, UserConfig } from '@modern-js/app-tools';
+type AppToolsUserConfig<T extends Bundler> = AppTools<T>['userConfig']['tools'];
+type ExcludeUndefined<T> = T extends undefined ? never : T;
+type ExtractObjectType<T> = T extends (...args: any[]) => any ? never : T;
+type OmitArrayConfiguration<T> = T extends Array<any> ? (T extends (infer U)[] ? U : T) : ExtractObjectType<T>;
+type WebpackConfigs = ExcludeUndefined<AppToolsUserConfig<'webpack'>> extends {
+    webpack?: infer U;
+} ? U : never;
+type ObjectWebpack = ExtractObjectType<OmitArrayConfiguration<WebpackConfigs>>;
+type RspackConfigs = ExcludeUndefined<AppToolsUserConfig<'rspack'>> extends {
+    rspack?: infer U;
+} ? U : never;
+type ObjectRspack = ExtractObjectType<OmitArrayConfiguration<RspackConfigs>>;
+type BundlerChain = ExcludeUndefined<ExcludeUndefined<UserConfig<AppTools>['tools']>['bundlerChain']>;
+type BundlerChainFunc = Extract<BundlerChain, (chain: any, utils: any) => any>;
+export type BundlerChainConfig = Parameters<BundlerChainFunc>[0];
+export type BundlerConfig<T extends Bundler> = T extends 'rspack' ? ObjectRspack : ObjectWebpack;
+export {};

package/dist/types/interfaces/global.d.ts

@@ -0,0 +1,27 @@
+import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from '../constant';
+export type DataFetchParams = {
+    isDowngrade: boolean;
+} & Record<string, unknown>;
+export type DataFetch<T> = (params: DataFetchParams) => Promise<T>;
+export type MF_DATA_FETCH_MAP_VALUE = [
+    [
+        () => Promise<DataFetch<unknown>>,
+        MF_DATA_FETCH_TYPE,
+        Promise<DataFetch<unknown>>?
+    ],
+    [
+        Promise<unknown>,
+        ((data: unknown) => void)?,
+        ((err: unknown) => void)?
+    ]?,
+    MF_DATA_FETCH_STATUS?
+];
+export type MF_DATA_FETCH_MAP = Record<string, MF_DATA_FETCH_MAP_VALUE>;
+export type MF_SSR_DOWNGRADE = string[] | true | undefined;
+export type NoSSRRemoteInfo = {
+    name: string;
+    version: string;
+    ssrPublicPath: string;
+    ssrRemoteEntry: string;
+    globalName: string;
+};

package/dist/types/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("@module-federation/sdk").Logger;
+export default logger;

package/dist/types/runtime/AwaitDataFetch.d.ts

@@ -0,0 +1,19 @@
+import React, { ReactNode } from 'react';
+import type { DataFetchParams } from '../interfaces/global';
+export type ErrorInfo = {
+    error: Error;
+    errorType: number;
+    dataFetchMapKey?: string;
+};
+export declare const transformError: (err: string | Error) => ErrorInfo;
+export interface AwaitProps<T> {
+    resolve: T | Promise<T>;
+    loading?: ReactNode;
+    errorElement?: ReactNode | ((errorInfo: ErrorInfo) => ReactNode);
+    children: (data: T) => ReactNode;
+    params?: DataFetchParams;
+}
+export interface AwaitErrorHandlerProps<T = any> extends Omit<AwaitProps<T>, 'resolve'> {
+    resolve: () => T | string;
+}
+export declare function AwaitDataFetch<T>({ resolve, loading, errorElement, children, params, }: AwaitProps<T>): React.JSX.Element;

package/dist/types/runtime/createRemoteComponent.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactNode } from 'react';
+import type { ErrorInfo } from './AwaitDataFetch';
+import type { DataFetchParams } from '../interfaces/global';
+type IProps = {
+    id: string;
+    injectScript?: boolean;
+    injectLink?: boolean;
+};
+export type CreateRemoteComponentOptions<T, E extends keyof T> = {
+    loader: () => Promise<T>;
+    loading: React.ReactNode;
+    fallback: ReactNode | ((errorInfo: ErrorInfo) => ReactNode);
+    export?: E;
+    dataFetchParams?: DataFetchParams;
+    noSSR?: boolean;
+};
+type ReactKey = {
+    key?: React.Key | null;
+};
+export declare function collectSSRAssets(options: IProps): React.ReactNode[];
+export declare function createRemoteComponent<T, E extends keyof T>(options: CreateRemoteComponentOptions<T, E>): (props: T[E] extends (...args: any) => any ? Parameters<T[E]>[0] extends undefined ? ReactKey : Parameters<T[E]>[0] & ReactKey : ReactKey) => React.JSX.Element;
+/**
+ * @deprecated createRemoteSSRComponent is deprecated, please use createRemoteComponent instead!
+ */
+export declare function createRemoteSSRComponent<T, E extends keyof T>(options: CreateRemoteComponentOptions<T, E>): (props: T[E] extends (...args: any) => any ? Parameters<T[E]>[0] extends undefined ? ReactKey : Parameters<T[E]>[0] & ReactKey : ReactKey) => React.JSX.Element;
+export {};

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,10 @@
+export * from '@module-federation/enhanced/runtime';
+export type { DataFetchParams } from '../interfaces/global';
+export { ERROR_TYPE } from '../constant';
+export declare const kit: {
+    readonly createRemoteSSRComponent: typeof import("./createRemoteComponent").createRemoteSSRComponent;
+    readonly createRemoteComponent: typeof import("./createRemoteComponent").createRemoteComponent;
+    readonly collectSSRAssets: typeof import("./createRemoteComponent").collectSSRAssets;
+    readonly wrapNoSSR: typeof import("./wrapNoSSR").wrapNoSSR;
+};
+export { setSSREnv } from '../ssr-runtime/injectDataFetchFunctionPlugin';

package/dist/types/runtime/wrapNoSSR.d.ts

@@ -0,0 +1,9 @@
+import { createRemoteComponent } from './createRemoteComponent';
+import type { CreateRemoteComponentOptions } from './createRemoteComponent';
+export declare function wrapNoSSR<T, E extends keyof T>(createComponentFn: typeof createRemoteComponent<T, E>): (options: Omit<CreateRemoteComponentOptions<T, E>, "noSSR">) => (props: T[E] extends (...args: any) => any ? Parameters<T[E]>[0] extends undefined ? {
+    key?: import("react").Key | null;
+} : Parameters<T[E]>[0] & {
+    key?: import("react").Key | null;
+} : {
+    key?: import("react").Key | null;
+}) => import("react").JSX.Element;

package/dist/types/server/fileCache.d.ts

@@ -0,0 +1,14 @@
+export interface FileResult {
+    content: string;
+    lastModified: number;
+}
+export declare class FileCache {
+    private cache;
+    /**
+     * Check if file exists and return file info
+     * @param filepath Path to the file
+     * @returns FileResult or null if file doesn't exist
+     */
+    getFile(filepath: string): Promise<FileResult | null>;
+}
+export declare const fileCache: FileCache;

package/dist/types/server/fileCache.spec.d.ts

@@ -0,0 +1 @@
+export {};