@module-federation/bridge-react 0.16.0 → 0.17.1

package/dist/lazy-utils.d.ts

@@ -0,0 +1,149 @@
+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>;
+    }
+}

package/dist/lazy-utils.es.js

@@ -0,0 +1,24 @@
+import "./index.esm-BCeUd-x9.mjs";
+import { G, H, f, J, I, u, k, n, g, m, B, y, i, q, j, t, a, z, s, w } from "./utils-C4oPJV34.mjs";
+export {
+  G as callAllDowngrade,
+  H as callDowngrade,
+  f as fetchData,
+  J as flushDataFetch,
+  I as getDataFetchCache,
+  u as getDataFetchIdWithErrorMsgs,
+  k as getDataFetchInfo,
+  n as getDataFetchItem,
+  g as getDataFetchMap,
+  m as getDataFetchMapKey,
+  B as getDowngradeTag,
+  y as getLoadedRemoteInfos,
+  i as initDataFetchMap,
+  q as isCSROnly,
+  j as isDataLoaderExpose,
+  t as isServerEnv,
+  a as loadDataFetchModule,
+  z as setDataFetchItemLoadedStatus,
+  s as setSSREnv,
+  w as wrapDataFetchId
+};

package/dist/plugin.d.ts

@@ -1,13 +1,22 @@
-import { FederationHost } from '@module-federation/runtime';
-import { FederationRuntimePlugin } from '@module-federation/runtime';
+import { ModuleFederation } from '@module-federation/runtime';
+import { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
 
-declare function BridgeReactPlugin(): FederationRuntimePlugin;
+declare function BridgeReactPlugin(): ModuleFederationRuntimePlugin;
 export default BridgeReactPlugin;
 
 export declare const federationRuntime: FederationRuntimeType;
 
 export declare type FederationRuntimeType = {
-    instance: FederationHost | null;
+    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>;
+    }
+}