@module-federation/bridge-react 2.7.0 → 2.8.0

package/dist/index.es.js

@@ -1,12 +1,12 @@
-import { R as RemoteAppWrapper, c as createRemoteAppComponentFactory, a as createDeprecatedRemoteComponentFactory } from "./createHelpers-BY5Uj9_Z.mjs";
-import { b } from "./createHelpers-BY5Uj9_Z.mjs";
-import { a, c, b as b2, l } from "./lazy-load-component-plugin-aj97Vt-4.mjs";
-import { C, a as a2, E, c as c2, b as b3, d, g, r, s } from "./utils-DGS4pYp8.mjs";
+import { R as RemoteAppWrapper, c as createRemoteAppComponentFactory, a as createDeprecatedRemoteComponentFactory } from "./createHelpers-BSHeKyd-.mjs";
+import { b } from "./createHelpers-BSHeKyd-.mjs";
+import { a, c, b as b2, l } from "./lazy-load-component-plugin-DEu-DfZt.mjs";
+import { C, a as a2, E, c as c2, b as b3, d, g, r, s } from "./utils-BBP3hEeV.mjs";
 import { callDataFetch } from "./data-fetch-utils.es.js";
 import React__default, { forwardRef, useContext, useState, useEffect } from "react";
 import * as ReactRouterDOM from "react-router-dom";
 import { p as pathJoin, L as LoggerInstance } from "./index-Bs2NxD2z.mjs";
-import { p } from "./prefetch-BwRDb4SJ.mjs";
+import { p } from "./prefetch-CTZuFBqh.mjs";
 function e() {
   const t = new PopStateEvent("popstate", { state: window.history.state });
   window.dispatchEvent(t);

package/dist/lazy/AwaitDataFetch.d.ts

@@ -0,0 +1,24 @@
+import React, { ReactNode } from 'react';
+import type { DataFetchParams } from './types';
+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;
+    delayLoading?: number;
+    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, delayLoading, }: AwaitProps<T>): React.JSX.Element;
+export declare const DelayedLoading: ({ delayLoading, children, }: {
+    delayLoading?: number;
+    children: ReactNode;
+}) => ReactNode;

package/dist/lazy/constant.d.ts

@@ -0,0 +1,26 @@
+export declare const PLUGIN_IDENTIFIER = "[ Module Federation React ]";
+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
+}
+export declare const DATA_FETCH_IDENTIFIER = "data";
+export declare const DATA_FETCH_CLIENT_SUFFIX = ".client";
+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: ";

package/dist/lazy/createLazyComponent.d.ts

@@ -0,0 +1,28 @@
+import type { getInstance } from '@module-federation/runtime';
+import React, { ReactNode } from 'react';
+import type { ErrorInfo } from './AwaitDataFetch';
+import type { DataFetchParams } from './types';
+export type IProps = {
+    id: string;
+    instance: ReturnType<typeof getInstance>;
+    injectScript?: boolean;
+    injectLink?: boolean;
+};
+export type CreateLazyComponentOptions<T, E extends keyof T> = {
+    loader: () => Promise<T>;
+    instance: ReturnType<typeof getInstance>;
+    loading: React.ReactNode;
+    delayLoading?: number;
+    fallback: ReactNode | ((errorInfo: ErrorInfo) => ReactNode);
+    export?: E;
+    dataFetchParams?: DataFetchParams;
+    noSSR?: boolean;
+    injectScript?: boolean;
+    injectLink?: boolean;
+};
+type ReactKey = {
+    key?: React.Key | null;
+};
+export declare function collectSSRAssets(options: IProps): ReactNode[];
+export declare function createLazyComponent<T, E extends keyof T>(options: CreateLazyComponentOptions<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/lazy/data-fetch/cache.d.ts

@@ -0,0 +1,34 @@
+import type { CacheConfig, DataFetch, DataFetchParams } from '../types';
+export declare const CacheSize: {
+    readonly KB: 1024;
+    readonly MB: number;
+    readonly GB: number;
+};
+export declare const CacheTime: {
+    readonly SECOND: 1000;
+    readonly MINUTE: number;
+    readonly HOUR: number;
+    readonly DAY: number;
+    readonly WEEK: number;
+    readonly MONTH: number;
+};
+export type CacheStatus = 'hit' | 'stale' | 'miss';
+export interface CacheStatsInfo {
+    status: CacheStatus;
+    key: string | symbol;
+    params: DataFetchParams;
+    result: any;
+}
+interface CacheOptions {
+    tag?: string | string[];
+    maxAge?: number;
+    revalidate?: number;
+    getKey?: <Args extends any[]>(...args: Args) => string;
+    onCache?: (info: CacheStatsInfo) => boolean;
+}
+export declare function configureCache(config: CacheConfig): void;
+export declare function generateKey(dataFetchOptions: DataFetchParams): string;
+export declare function cache<T>(fn: DataFetch<T>, options?: CacheOptions): DataFetch<T>;
+export declare function revalidateTag(tag: string): void;
+export declare function clearStore(): void;
+export {};

package/dist/lazy/data-fetch/cache.spec.d.ts

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

package/dist/lazy/data-fetch/call-data-fetch.d.ts

@@ -0,0 +1 @@
+export declare function callDataFetch(): Promise<void>;

package/dist/lazy/data-fetch/data-fetch-server-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from 'hono';
+declare const dataFetchServerMiddleware: MiddlewareHandler;
+export default dataFetchServerMiddleware;

package/dist/lazy/data-fetch/index.d.ts

@@ -0,0 +1,6 @@
+export { callDataFetch } from './call-data-fetch';
+export { injectDataFetch } from './inject-data-fetch';
+export { CacheSize, CacheTime, configureCache, generateKey, cache, revalidateTag, clearStore, } from './cache';
+export type { CacheStatus, CacheStatsInfo } from './cache';
+export type { PrefetchOptions } from './prefetch';
+export { prefetch } from './prefetch';

package/dist/lazy/data-fetch/inject-data-fetch.d.ts

@@ -0,0 +1,4 @@
+import { dataFetchFunctionOptions } from '../types';
+declare const dataFetchFunction: (options: dataFetchFunctionOptions) => Promise<unknown>;
+export declare function injectDataFetch(): void;
+export { dataFetchFunction };

package/dist/lazy/data-fetch/prefetch.d.ts

@@ -0,0 +1,9 @@
+import type { getInstance } from '@module-federation/runtime';
+import { DataFetchParams } from '../types';
+export type PrefetchOptions = {
+    id: string;
+    instance: ReturnType<typeof getInstance>;
+    dataFetchParams?: DataFetchParams;
+    preloadComponentResource?: boolean;
+};
+export declare function prefetch(options: PrefetchOptions): Promise<void>;

package/dist/lazy/data-fetch/runtime-plugin.d.ts

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

package/dist/lazy/index.d.ts

@@ -0,0 +1,9 @@
+import autoFetchDataPlugin from './data-fetch/runtime-plugin';
+export { ERROR_TYPE } from './constant';
+export type { DataFetchParams, NoSSRRemoteInfo } from './types';
+export type { CreateLazyComponentOptions, IProps as CollectSSRAssetsOptions, } from './createLazyComponent';
+export { createLazyComponent, collectSSRAssets } from './createLazyComponent';
+export { injectDataFetch, callDataFetch, CacheSize, CacheTime, configureCache, generateKey, cache, revalidateTag, clearStore, prefetch, } from './data-fetch';
+export { setSSREnv } from './utils';
+export { autoFetchDataPlugin };
+export type { CacheStatus, CacheStatsInfo, PrefetchOptions, } from './data-fetch';

package/dist/lazy/logger.d.ts

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

package/dist/lazy/types.d.ts

@@ -0,0 +1,60 @@
+import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from './constant';
+import type { SizeLimitedCache } from '../shared/size-limited-cache';
+export type dataFetchFunctionOptions = [
+    id?: string,
+    data?: unknown,
+    downgrade?: boolean
+];
+declare global {
+    var _mfSSRDowngrade: string[] | true | undefined;
+    var __MF_DATA_FETCH_MAP__: MF_DATA_FETCH_MAP | undefined;
+    var FEDERATION_SERVER_QUERY: Record<string, unknown> | undefined;
+    var FEDERATION_SSR: boolean | undefined;
+    var _mfFSHref: string | undefined;
+    var _mfDataFetch: Array<dataFetchFunctionOptions> | undefined;
+    var __MF_DATA_FETCH_CACHE__: MF_DATA_FETCH_CACHE | undefined;
+}
+export interface CacheItem<T> {
+    data: T;
+    timestamp: number;
+    isRevalidating?: boolean;
+}
+export type DataFetchParams = {
+    isDowngrade: boolean;
+    _id?: string;
+} & Record<string, unknown>;
+export type DataFetch<T> = (params: DataFetchParams) => Promise<T>;
+export type MF_DATA_FETCH_MAP_VALUE_PROMISE_SET = [
+    Promise<unknown>,
+    ((data: unknown) => void)?,
+    ((err: unknown) => void)?
+];
+export type MF_DATA_FETCH_MAP_VALUE = [
+    [
+        () => Promise<DataFetch<unknown>>,
+        MF_DATA_FETCH_TYPE,
+        Promise<DataFetch<unknown>>?
+    ],
+    MF_DATA_FETCH_MAP_VALUE_PROMISE_SET?,
+    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;
+};
+export interface CacheConfig {
+    maxSize?: number;
+    unstable_shouldDisable?: ({ request, }: {
+        request: Request;
+    }) => boolean | Promise<boolean>;
+}
+export type MF_DATA_FETCH_CACHE = {
+    cacheStore?: SizeLimitedCache<string, Map<string, CacheItem<any>>>;
+    tagKeyMap?: Map<string, Set<string>>;
+    cacheConfig?: CacheConfig;
+};

package/dist/lazy/utils.d.ts

@@ -0,0 +1,48 @@
+import type { GlobalModuleInfo } from '@module-federation/sdk';
+import type { DataFetchParams, MF_DATA_FETCH_MAP, NoSSRRemoteInfo, MF_SSR_DOWNGRADE, MF_DATA_FETCH_CACHE } from './types';
+import type { ModuleFederation } from '@module-federation/runtime';
+export declare const getDataFetchInfo: ({ name, alias, id, remoteSnapshot, }: {
+    id: string;
+    name: string;
+    remoteSnapshot: GlobalModuleInfo[string];
+    alias?: string;
+}) => {
+    dataFetchName: string;
+    dataFetchId: string;
+    dataFetchKey: string;
+} | undefined;
+export declare function initDataFetchMap(): void;
+export declare function getDataFetchItem(id: string): import("./types").MF_DATA_FETCH_MAP_VALUE;
+export declare function getDataFetchMap(): MF_DATA_FETCH_MAP;
+export declare function getDataFetchCache(): MF_DATA_FETCH_CACHE;
+export declare const flushDataFetch: () => void;
+export declare function setDataFetchItemLoadedStatus(id: string): void;
+export declare const wrapDataFetchId: (id?: string) => string;
+export declare const getDataFetchIdWithErrorMsgs: (errMsgs: string) => string | undefined;
+export declare function fetchData(id: string, params: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown | undefined>;
+export declare function getDataFetchMapKey(dataFetchInfo?: ReturnType<typeof getDataFetchInfo>, hostInfo?: {
+    name: string;
+    version?: string;
+}): string | undefined;
+export declare function loadDataFetchModule(instance: ModuleFederation, id: string): Promise<(params: DataFetchParams) => Promise<unknown>>;
+export declare function isDataLoaderExpose(exposeKey: string): boolean;
+export declare function getDowngradeTag(): MF_SSR_DOWNGRADE;
+export declare function callAllDowngrade(): void;
+export declare function callDowngrade(id: string, params?: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown>;
+export declare function isCSROnly(): boolean;
+export declare function isServerEnv(): boolean;
+export declare function setSSREnv({ fetchServerQuery, }: {
+    fetchServerQuery?: Record<string, unknown>;
+}): void;
+export declare function getLoadedRemoteInfos(id: string, instance: ModuleFederation | null): {
+    alias?: string;
+    name: string;
+    version?: string;
+    buildVersion?: string;
+    entry: string;
+    type: import("@module-federation/sdk").RemoteEntryType;
+    entryGlobalName: string;
+    shareScope: string | string[];
+    snapshot: import("@module-federation/sdk").ManifestProvider | import("@module-federation/sdk").PureEntryProvider | import("@module-federation/sdk").ModuleInfo | undefined;
+    expose: string;
+} | undefined;

package/dist/lazy/wrapNoSSR.d.ts

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

package/dist/{lazy-load-component-plugin-aj97Vt-4.mjs → lazy-load-component-plugin-DEu-DfZt.mjs}

@@ -1,5 +1,5 @@
-import { i as injectDataFetch, p as prefetch } from "./prefetch-BwRDb4SJ.mjs";
-import { i as initDataFetchMap, k as isDataLoaderExpose, m as getDataFetchInfo, n as getDataFetchMapKey, l as logger, o as getDataFetchItem, p as DATA_FETCH_CLIENT_SUFFIX, q as MF_DATA_FETCH_TYPE, t as isCSROnly, M as MF_DATA_FETCH_STATUS, j as loadDataFetchModule, e as getDataFetchMap, u as isServerEnv, v as getDataFetchIdWithErrorMsgs, w as DATA_FETCH_ERROR_PREFIX, E as ERROR_TYPE, x as wrapDataFetchId, L as LOAD_REMOTE_ERROR_PREFIX, y as DATA_FETCH_FUNCTION, z as getLoadedRemoteInfos, h as fetchData$1, A as setDataFetchItemLoadedStatus, F as FS_HREF } from "./utils-DGS4pYp8.mjs";
+import { i as injectDataFetch, p as prefetch } from "./prefetch-CTZuFBqh.mjs";
+import { i as initDataFetchMap, k as isDataLoaderExpose, m as getDataFetchInfo, n as getDataFetchMapKey, l as logger, o as getDataFetchItem, p as DATA_FETCH_CLIENT_SUFFIX, q as MF_DATA_FETCH_TYPE, t as isCSROnly, M as MF_DATA_FETCH_STATUS, j as loadDataFetchModule, e as getDataFetchMap, u as isServerEnv, v as getDataFetchIdWithErrorMsgs, w as DATA_FETCH_ERROR_PREFIX, E as ERROR_TYPE, x as wrapDataFetchId, L as LOAD_REMOTE_ERROR_PREFIX, y as DATA_FETCH_FUNCTION, z as getLoadedRemoteInfos, h as fetchData$1, A as setDataFetchItemLoadedStatus, F as FS_HREF } from "./utils-BBP3hEeV.mjs";
 import React__default, { useRef, useState, Suspense, useEffect } from "react";
 const autoFetchData = () => {
   initDataFetchMap();

package/dist/{lazy-load-component-plugin-BjMVNoep.js → lazy-load-component-plugin-FKp6nQa-.js}

@@ -1,6 +1,6 @@
 "use strict";
-const prefetch = require("./prefetch-DLhPTofn.js");
-const lazyUtils = require("./utils-CFTy4LVE.js");
+const prefetch = require("./prefetch-D66kL1aM.js");
+const lazyUtils = require("./utils-5dGErM3C.js");
 const React = require("react");
 const autoFetchData = () => {
   lazyUtils.initDataFetchMap();

package/dist/lazy-load-component-plugin.cjs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const lazyLoadComponentPlugin = require("./lazy-load-component-plugin-BjMVNoep.js");
-require("./prefetch-DLhPTofn.js");
+const lazyLoadComponentPlugin = require("./lazy-load-component-plugin-FKp6nQa-.js");
+require("./prefetch-D66kL1aM.js");
 exports.default = lazyLoadComponentPlugin.lazyLoadComponentPlugin;
 exports.lazyLoadComponentPlugin = lazyLoadComponentPlugin.lazyLoadComponentPlugin;

package/dist/lazy-load-component-plugin.d.ts

@@ -1,16 +1,2 @@
-import { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-
-declare function lazyLoadComponentPlugin(): ModuleFederationRuntimePlugin;
-export default lazyLoadComponentPlugin;
-export { lazyLoadComponentPlugin }
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export { default } from './plugins/lazy-load-component-plugin';
+export * from './plugins/lazy-load-component-plugin';

package/dist/lazy-load-component-plugin.es.js

@@ -1,5 +1,5 @@
-import { l, l as l2 } from "./lazy-load-component-plugin-aj97Vt-4.mjs";
-import "./prefetch-BwRDb4SJ.mjs";
+import { l, l as l2 } from "./lazy-load-component-plugin-DEu-DfZt.mjs";
+import "./prefetch-CTZuFBqh.mjs";
 export {
   l as default,
   l2 as lazyLoadComponentPlugin

package/dist/lazy-utils.cjs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./logger-Dxblx6P-.js");
-const lazyUtils = require("./utils-CFTy4LVE.js");
+const lazyUtils = require("./utils-5dGErM3C.js");
 exports.callAllDowngrade = lazyUtils.callAllDowngrade;
 exports.callDowngrade = lazyUtils.callDowngrade;
 exports.fetchData = lazyUtils.fetchData;

package/dist/lazy-utils.d.ts

@@ -1,149 +1 @@
-import { GlobalModuleInfo } from '@module-federation/sdk';
-import { LRUCache } from 'lru-cache';
-import { ManifestProvider } from '@module-federation/sdk';
-import { ModuleFederation } from '@module-federation/runtime';
-import { ModuleInfo } from '@module-federation/sdk';
-import { PureEntryProvider } from '@module-federation/sdk';
-import { RemoteEntryType } from '@module-federation/sdk';
-
-declare interface CacheConfig {
-    maxSize?: number;
-    unstable_shouldDisable?: ({ request, }: {
-        request: Request;
-    }) => boolean | Promise<boolean>;
-}
-
-declare interface CacheItem<T> {
-    data: T;
-    timestamp: number;
-    isRevalidating?: boolean;
-}
-
-export declare function callAllDowngrade(): void;
-
-export declare function callDowngrade(id: string, params?: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown>;
-
-declare type DataFetch<T> = (params: DataFetchParams) => Promise<T>;
-
-declare type DataFetchParams = {
-    isDowngrade: boolean;
-    _id?: string;
-} & Record<string, unknown>;
-
-export declare function fetchData(id: string, params: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown | undefined>;
-
-export declare const flushDataFetch: () => void;
-
-export declare function getDataFetchCache(): MF_DATA_FETCH_CACHE;
-
-export declare const getDataFetchIdWithErrorMsgs: (errMsgs: string) => string | undefined;
-
-export declare const getDataFetchInfo: ({ name, alias, id, remoteSnapshot, }: {
-    id: string;
-    name: string;
-    remoteSnapshot: GlobalModuleInfo[string];
-    alias?: string;
-}) => {
-    dataFetchName: string;
-    dataFetchId: string;
-    dataFetchKey: string;
-} | undefined;
-
-export declare function getDataFetchItem(id: string): MF_DATA_FETCH_MAP_VALUE;
-
-export declare function getDataFetchMap(): MF_DATA_FETCH_MAP;
-
-export declare function getDataFetchMapKey(dataFetchInfo?: ReturnType<typeof getDataFetchInfo>, hostInfo?: {
-    name: string;
-    version?: string;
-}): string | undefined;
-
-export declare function getDowngradeTag(): MF_SSR_DOWNGRADE;
-
-export declare function getLoadedRemoteInfos(id: string, instance: ModuleFederation | null): {
-    snapshot: ModuleInfo | ManifestProvider | PureEntryProvider | undefined;
-    expose: string;
-    alias?: string;
-    name: string;
-    version?: string;
-    buildVersion?: string;
-    entry: string;
-    type: RemoteEntryType;
-    entryGlobalName: string;
-    shareScope: string | string[];
-} | undefined;
-
-export declare function initDataFetchMap(): void;
-
-export declare function isCSROnly(): boolean;
-
-export declare function isDataLoaderExpose(exposeKey: string): boolean;
-
-export declare function isServerEnv(): boolean;
-
-export declare function loadDataFetchModule(instance: ModuleFederation, id: string): Promise<(params: DataFetchParams) => Promise<unknown>>;
-
-declare type MF_DATA_FETCH_CACHE = {
-    cacheStore?: LRUCache<string, Map<string, CacheItem<any>>>;
-    tagKeyMap?: Map<string, Set<string>>;
-    cacheConfig?: CacheConfig;
-};
-
-declare type MF_DATA_FETCH_MAP = Record<string, MF_DATA_FETCH_MAP_VALUE>;
-
-declare type MF_DATA_FETCH_MAP_VALUE = [
-[
-() => Promise<DataFetch<unknown>>,
-MF_DATA_FETCH_TYPE,
-Promise<DataFetch<unknown>>?
-],
-MF_DATA_FETCH_MAP_VALUE_PROMISE_SET?,
-MF_DATA_FETCH_STATUS?
-];
-
-declare type MF_DATA_FETCH_MAP_VALUE_PROMISE_SET = [
-Promise<unknown>,
-((data: unknown) => void)?,
-((err: unknown) => void)?
-];
-
-declare const enum MF_DATA_FETCH_STATUS {
-    LOADED = 1,
-    LOADING = 2,
-    AWAIT = 0,
-    ERROR = 3
-}
-
-declare const enum MF_DATA_FETCH_TYPE {
-    FETCH_SERVER = 1,
-    FETCH_CLIENT = 2
-}
-
-declare type MF_SSR_DOWNGRADE = string[] | true | undefined;
-
-declare type NoSSRRemoteInfo = {
-    name: string;
-    version: string;
-    ssrPublicPath: string;
-    ssrRemoteEntry: string;
-    globalName: string;
-};
-
-export declare function setDataFetchItemLoadedStatus(id: string): void;
-
-export declare function setSSREnv({ fetchServerQuery, }: {
-    fetchServerQuery?: Record<string, unknown>;
-}): void;
-
-export declare const wrapDataFetchId: (id?: string) => string;
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export * from './lazy/utils';

package/dist/lazy-utils.es.js

@@ -1,11 +1,11 @@
 import "./logger-DwWkXsWl.mjs";
-import { H, I, h, f, N, v, m, o, e, n, J, z, i, t, k, u, j, A, s, x } from "./utils-DGS4pYp8.mjs";
+import { H, I, h, f, O, v, m, o, e, n, J, z, i, t, k, u, j, A, s, x } from "./utils-BBP3hEeV.mjs";
 export {
   H as callAllDowngrade,
   I as callDowngrade,
   h as fetchData,
   f as flushDataFetch,
-  N as getDataFetchCache,
+  O as getDataFetchCache,
   v as getDataFetchIdWithErrorMsgs,
   m as getDataFetchInfo,
   o as getDataFetchItem,

package/dist/plugin.d.ts

@@ -1,22 +1,2 @@
-import { ModuleFederation } from '@module-federation/runtime';
-import { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-
-declare function BridgeReactPlugin(): ModuleFederationRuntimePlugin;
-export default BridgeReactPlugin;
-
-export declare const federationRuntime: FederationRuntimeType;
-
-export declare type FederationRuntimeType = {
-    instance: ModuleFederation | null;
-};
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export { default } from './provider/plugin';
+export * from './provider/plugin';

package/dist/plugins/lazy-load-component-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import { createLazyComponent, prefetch, collectSSRAssets } from '../lazy';
+import type { CreateLazyComponentOptions, PrefetchOptions } from '../lazy';
+declare module '@module-federation/runtime-core' {
+    interface ModuleFederation {
+        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
+        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
+        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
+    }
+}
+export declare function lazyLoadComponentPlugin(): ModuleFederationRuntimePlugin;
+export default lazyLoadComponentPlugin;

package/dist/plugins/lazy-load-component-plugin.spec.d.ts

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