@module-federation/sdk 0.0.0-next-20231220075820 → 0.0.0-next-20231220081137

package/dist/normalize-webpack-path.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/normalize-webpack-path";

package/dist/normalize-webpack-path.cjs.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+function getWebpackPath(compiler) {
+    try {
+        // @ts-ignore just throw err
+        compiler.webpack();
+        return "";
+    } catch (err) {
+        var _err_stack;
+        var trace = ((_err_stack = err.stack) === null || _err_stack === void 0 ? void 0 : _err_stack.split("\n")) || [];
+        var webpackErrLocation = trace.find(function(item) {
+            return item.includes("at webpack");
+        }) || "";
+        var webpackLocationWithDetail = webpackErrLocation.replace(/[^\(\)]+/, "").slice(1, -1);
+        var webpackPath = webpackLocationWithDetail.split(":").slice(0, -2)[0];
+        return require.resolve("webpack", {
+            paths: [
+                webpackPath
+            ]
+        });
+    }
+}
+var normalizeWebpackPath = function(fullPath) {
+    if (fullPath === "webpack") {
+        return process.env["FEDERATION_WEBPACK_PATH"] || fullPath;
+    }
+    if (process.env["FEDERATION_WEBPACK_PATH"]) {
+        return path__default["default"].resolve(process.env["FEDERATION_WEBPACK_PATH"], fullPath.replace("webpack", "../../"));
+    }
+    return fullPath;
+};
+
+exports.getWebpackPath = getWebpackPath;
+exports.normalizeWebpackPath = normalizeWebpackPath;

package/dist/normalize-webpack-path.esm.js

@@ -0,0 +1,33 @@
+import path from 'path';
+
+function getWebpackPath(compiler) {
+    try {
+        // @ts-ignore just throw err
+        compiler.webpack();
+        return "";
+    } catch (err) {
+        var _err_stack;
+        var trace = ((_err_stack = err.stack) === null || _err_stack === void 0 ? void 0 : _err_stack.split("\n")) || [];
+        var webpackErrLocation = trace.find(function(item) {
+            return item.includes("at webpack");
+        }) || "";
+        var webpackLocationWithDetail = webpackErrLocation.replace(/[^\(\)]+/, "").slice(1, -1);
+        var webpackPath = webpackLocationWithDetail.split(":").slice(0, -2)[0];
+        return require.resolve("webpack", {
+            paths: [
+                webpackPath
+            ]
+        });
+    }
+}
+var normalizeWebpackPath = function(fullPath) {
+    if (fullPath === "webpack") {
+        return process.env["FEDERATION_WEBPACK_PATH"] || fullPath;
+    }
+    if (process.env["FEDERATION_WEBPACK_PATH"]) {
+        return path.resolve(process.env["FEDERATION_WEBPACK_PATH"], fullPath.replace("webpack", "../../"));
+    }
+    return fullPath;
+};
+
+export { getWebpackPath, normalizeWebpackPath };

package/dist/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@module-federation/sdk",
+  "version": "0.0.3",
+  "license": "MIT",
+  "description": "A sdk for support module federation",
+  "keywords": [
+    "Module Federation",
+    "sdk"
+  ],
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "zhanghang <hanric.zhang@gmail.com>",
+  "sideEffects": false,
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./dist/index.cjs.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js",
+      "types": "./dist/index.cjs.d.ts"
+    },
+    "./normalize-webpack-path": {
+      "import": "./dist/normalize-webpack-path.esm.js",
+      "require": "./dist/normalize-webpack-path.cjs.js",
+      "types": "./dist/src/normalize-webpack-path.cjs.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.cjs.d.ts"
+      ],
+      "normalize-webpack-path": [
+        "./dist/normalize-webpack-path.cjs.d.ts"
+      ]
+    }
+  }
+}

package/dist/src/constant.d.ts

@@ -0,0 +1,16 @@
+export declare const FederationModuleManifest = "federation-manifest.json";
+export declare const MANIFEST_EXT = ".json";
+export declare const BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+export declare const BROWSER_LOG_VALUE = "1";
+export declare const NameTransformSymbol: {
+    AT: string;
+    HYPHEN: string;
+    SLASH: string;
+};
+export declare const NameTransformMap: {
+    [x: string]: string;
+};
+export declare const EncodedNameTransformMap: {
+    [x: string]: string;
+};
+export declare const SEPARATOR = ":";

package/dist/src/dom.d.ts

@@ -0,0 +1,10 @@
+export declare function safeWrapper<T extends (...args: Array<any>) => any>(callback: T, disableWarn?: boolean): Promise<ReturnType<T> | undefined>;
+export declare function isStaticResourcesEqual(url1: string, url2: string): boolean;
+export declare function createScript(url: string, cb: (value: void | PromiseLike<void>) => void, attrs?: Record<string, any>, createScriptHook?: (url: string) => HTMLScriptElement | void): {
+    script: HTMLScriptElement;
+    needAttach: boolean;
+};
+export declare function loadScript(url: string, info: {
+    attrs?: Record<string, any>;
+    createScriptHook?: (url: string) => HTMLScriptElement | void;
+}): Promise<void>;

package/dist/src/env.d.ts

@@ -0,0 +1,7 @@
+declare global {
+    var FEDERATION_DEBUG: string | undefined;
+}
+declare function isBrowserEnv(): boolean;
+declare function isDebugMode(): boolean;
+declare const getProcessEnv: () => Record<string, string | undefined>;
+export { isBrowserEnv, isDebugMode, getProcessEnv };

package/dist/src/generateSnapshotFromManifest.d.ts

@@ -0,0 +1,10 @@
+import { Manifest, ProviderModuleInfo, ModuleInfo, ManifestProvider } from './types';
+interface IOptions {
+    remotes?: Record<string, string>;
+    overrides?: Record<string, string>;
+    version?: string;
+}
+export declare const simpleJoinRemoteEntry: (rPath: string, rName: string) => string;
+export declare function generateSnapshotFromManifest(manifest: Manifest, options?: IOptions): ProviderModuleInfo;
+export declare function isManifestProvider(moduleInfo: ModuleInfo | ManifestProvider): moduleInfo is ManifestProvider;
+export {};

package/{src/index.ts → dist/src/index.d.ts}

@@ -1,10 +1,7 @@
 export * from './constant';
 export * from './types';
 export * from './utils';
-export {
-  generateSnapshotFromManifest,
-  isManifestProvider,
-} from './generateSnapshotFromManifest';
+export { generateSnapshotFromManifest, isManifestProvider, } from './generateSnapshotFromManifest';
 export * from './logger';
 export * from './env';
 export * from './dom';

package/dist/src/logger.d.ts

@@ -0,0 +1,8 @@
+declare class Logger {
+    enable: boolean;
+    identifier: string;
+    constructor(identifier?: string);
+    info(msg: string, info?: any): void;
+    logOriginalInfo(...args: unknown[]): void;
+}
+export { Logger };

package/dist/src/normalize-webpack-path.d.ts

@@ -0,0 +1,3 @@
+import type webpack from 'webpack';
+export declare function getWebpackPath(compiler: webpack.Compiler): string;
+export declare const normalizeWebpackPath: (fullPath: string) => string;

package/{src/types/common.ts → dist/src/types/common.d.ts}

@@ -1,18 +1,10 @@
 export interface RemoteWithEntry {
-  name: string;
-  entry: string;
+    name: string;
+    entry: string;
 }
-
 export interface RemoteWithVersion {
-  name: string;
-  version: string;
+    name: string;
+    version: string;
 }
-
 export type RemoteEntryInfo = RemoteWithEntry | RemoteWithVersion;
 export type Module = any;
-
-declare namespace NodeJS {
-  interface ProcessEnv {
-    FEDERATION_WEBPACK_PATH?: string;
-  }
-}

package/dist/src/types/manifest.d.ts

@@ -0,0 +1,26 @@
+import { StatsMetaData, StatsAssets, StatsExpose, BasicStatsMetaData } from './stats';
+import { RemoteWithEntry, RemoteWithVersion } from './common';
+export interface ManifestShared {
+    id: string;
+    name: string;
+    version: string;
+    singleton: boolean;
+    requiredVersion: string;
+    hash: string;
+    assets: StatsAssets;
+}
+export interface ManifestRemoteCommonInfo {
+    federationContainerName: string;
+    moduleName: string;
+    alias: string;
+}
+export type ManifestRemote<T = ManifestRemoteCommonInfo> = (Omit<RemoteWithEntry, 'name'> & T) | (Omit<RemoteWithVersion, 'name'> & T);
+export type ManifestExpose = Pick<StatsExpose, 'assets' | 'id' | 'name' | 'path'>;
+export interface Manifest<T = BasicStatsMetaData, K = ManifestRemoteCommonInfo> {
+    id: string;
+    name: string;
+    metaData: StatsMetaData<T>;
+    shared: ManifestShared[];
+    remotes: ManifestRemote<K>[];
+    exposes: ManifestExpose[];
+}

package/dist/src/types/snapshot.d.ts

@@ -0,0 +1,62 @@
+import { RemoteEntryType, StatsAssets } from './stats';
+interface BasicModuleInfo {
+    dev?: {
+        version?: string;
+        remotes?: {
+            [nameWithType: string]: string;
+        };
+    };
+    version: string;
+    buildVersion: string;
+    remoteTypes: string;
+    remotesInfo: Record<string, {
+        matchedVersion: string;
+    }>;
+    shared: Array<{
+        sharedName: string;
+        assets: StatsAssets;
+    }>;
+}
+export interface BasicProviderModuleInfo extends BasicModuleInfo {
+    remoteEntry: string;
+    remoteEntryType: RemoteEntryType;
+    remoteManifest?: string;
+    globalName: string;
+    modules: Array<{
+        moduleName: string;
+        modulePath?: string;
+        assets: StatsAssets;
+    }>;
+    prefetchEntry?: string;
+    prefetchEntryType?: RemoteEntryType;
+}
+interface BasicProviderModuleInfoWithPublicPath extends BasicProviderModuleInfo {
+    publicPath: string;
+}
+interface BasicProviderModuleInfoWithGetPublicPath extends BasicProviderModuleInfo {
+    getPublicPath: string;
+}
+export interface ManifestProvider {
+    remoteEntry: string;
+    version?: string;
+}
+export interface PureEntryProvider extends ManifestProvider {
+    globalName: string;
+}
+interface BasicConsumerModuleInfo extends BasicModuleInfo {
+    consumerList: Array<string>;
+}
+export interface ConsumerModuleInfoWithPublicPath extends BasicConsumerModuleInfo, BasicProviderModuleInfo {
+    publicPath: string;
+}
+interface ConsumerModuleInfoWithGetPublicPath extends BasicConsumerModuleInfo, BasicProviderModuleInfo {
+    getPublicPath: string;
+}
+export type PureConsumerModuleInfo = Omit<BasicConsumerModuleInfo, 'remoteTypes'>;
+export type ConsumerModuleInfo = ConsumerModuleInfoWithPublicPath | ConsumerModuleInfoWithGetPublicPath;
+export type ProviderModuleInfo = BasicProviderModuleInfoWithPublicPath | BasicProviderModuleInfoWithGetPublicPath;
+export type ModuleInfo = ConsumerModuleInfo | PureConsumerModuleInfo | ProviderModuleInfo;
+export type GlobalModuleInfo = {
+    [key: string]: ModuleInfo | ManifestProvider | PureEntryProvider | undefined;
+};
+export {};

package/dist/src/types/stats.d.ts

@@ -0,0 +1,79 @@
+import type { RemoteWithEntry, RemoteWithVersion } from './common';
+export type RemoteEntryType = 'esm' | 'global';
+interface ResourceInfo {
+    path: string;
+    name: string;
+    type: RemoteEntryType;
+}
+export interface StatsBuildInfo {
+    buildVersion: string;
+    buildName: string;
+}
+export interface BasicStatsMetaData {
+    name: string;
+    globalName: string;
+    buildInfo: StatsBuildInfo;
+    remoteEntry: ResourceInfo;
+    prefetchEntry: ResourceInfo;
+    types: Omit<ResourceInfo, 'type'>;
+}
+type StatsMetaDataWithGetPublicPath<T = BasicStatsMetaData> = T & {
+    getPublicPath: string;
+};
+type StatsMetaDataWithPublicPath<T = BasicStatsMetaData> = T & {
+    publicPath: string;
+};
+export type StatsMetaData<T = BasicStatsMetaData> = StatsMetaDataWithGetPublicPath<T> | StatsMetaDataWithPublicPath<T>;
+export interface StatsAssets {
+    js: StatsAssetsInfo;
+    css: StatsAssetsInfo;
+}
+interface StatsAssetsInfo {
+    sync: string[];
+    async: string[];
+}
+export interface StatsShared {
+    id: string;
+    name: string;
+    version: string;
+    singleton: boolean;
+    requiredVersion: string;
+    hash: string;
+    assets: StatsAssets;
+    deps: string[];
+    usedIn: string[];
+}
+export interface StatsRemoteVal {
+    moduleName: string;
+    federationContainerName: string;
+    consumingFederationContainerName: string;
+    alias: string;
+    usedIn: string[];
+}
+export type StatsRemoteWithEntry<T = StatsRemoteVal> = T & Omit<RemoteWithEntry, 'name'>;
+export type StatsRemoteWithVersion<T = StatsRemoteVal> = T & Omit<RemoteWithVersion, 'name'>;
+export type StatsRemote<T = StatsRemoteVal> = StatsRemoteWithEntry<T> | StatsRemoteWithVersion<T>;
+export interface StatsModuleInfo {
+    name: string;
+    file: string;
+}
+export interface ManifestModuleInfos {
+    [exposeModuleName: string]: StatsModuleInfo;
+}
+export interface StatsExpose {
+    id: string;
+    name: string;
+    path?: string;
+    file: string;
+    requires: string[];
+    assets: StatsAssets;
+}
+export interface Stats<T = BasicStatsMetaData, K = StatsRemoteVal> {
+    id: string;
+    name: string;
+    metaData: StatsMetaData<T>;
+    shared: StatsShared[];
+    remotes: StatsRemote<K>[];
+    exposes: StatsExpose[];
+}
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,17 @@
+import { RemoteEntryInfo, ModuleInfo } from './types';
+import { Logger } from './logger';
+declare const parseEntry: (str: string, devVerOrUrl?: string) => RemoteEntryInfo;
+declare global {
+    var FEDERATION_DEBUG: string | undefined;
+}
+declare const logger: Logger;
+declare const composeKeyWithSeparator: (...args: (string | undefined)[]) => string;
+declare const encodeName: (name: string, prefix?: string, withExt?: boolean) => string;
+declare const decodeName: (name: string, prefix?: string, withExt?: boolean) => string;
+declare const generateExposeFilename: (exposeName: string, withExt: boolean) => string;
+declare const generateShareFilename: (pkgName: string, withExt: boolean) => string;
+declare const getResourceUrl: (module: ModuleInfo, sourceUrl: string) => string;
+declare const assert: (condition: any, msg: string) => asserts condition;
+declare const error: (msg: string | Error | unknown) => never;
+declare const warn: (msg: Parameters<typeof console.warn>[0]) => void;
+export { parseEntry, logger, decodeName, encodeName, composeKeyWithSeparator, generateExposeFilename, generateShareFilename, getResourceUrl, assert, error, warn, };

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@module-federation/sdk",
-  "version": "0.0.0-next-20231220075820",
+  "version": "0.0.0-next-20231220081137",
   "license": "MIT",
   "description": "A sdk for support module federation",
   "keywords": [
     "Module Federation",
     "sdk"
   ],
+  "files": [
+    "dist/",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public"
   },