@umijs/mfsu 4.0.0-canary.20220429.3 → 4.0.0-canary.20220429.4

package/dist/babelPlugins/awaitImport/awaitImport.d.ts

@@ -0,0 +1,27 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+export interface IOpts {
+    onTransformDeps?: Function;
+    onCollect?: Function;
+    exportAllMembers?: Record<string, string[]>;
+    unMatchLibs?: string[];
+    remoteName?: string;
+    alias?: Record<string, string>;
+    externals?: any;
+}
+export default function (): {
+    pre(): void;
+    post(state: any): void;
+    visitor: {
+        Program: {
+            exit(path: Babel.NodePath<t.Program>, { opts }: {
+                opts: IOpts;
+            }): void;
+        };
+        CallExpression: {
+            exit(path: Babel.NodePath<t.CallExpression>, { opts }: {
+                opts: IOpts;
+            }): void;
+        };
+    };
+};

package/dist/babelPlugins/awaitImport/awaitImport.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const t = __importStar(require("@umijs/bundler-utils/compiled/babel/types"));
+const checkMatch_1 = require("./checkMatch");
+function default_1() {
+    return {
+        pre() {
+            // @ts-ignore
+            this.cache = new Map();
+        },
+        post(state) {
+            var _a, _b;
+            // @ts-ignore
+            const { cache } = this;
+            if (cache.has(state.opts.filename)) {
+                // @ts-ignore
+                (_b = (_a = this.opts).onCollect) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                    file: state.opts.filename,
+                    data: cache.get(state.opts.filename),
+                });
+            }
+        },
+        visitor: {
+            Program: {
+                exit(path, { opts }) {
+                    let index = path.node.body.length - 1;
+                    while (index >= 0) {
+                        const node = path.node.body[index];
+                        // import x from 'x';
+                        // import * as x from 'x';
+                        // import x, * as xx from 'x';
+                        // import { x } from 'x';
+                        if (t.isImportDeclaration(node)) {
+                            const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                                // @ts-ignore
+                                cache: this.cache,
+                                value: node.source.value,
+                                opts,
+                                path,
+                            });
+                            if (isMatch) {
+                                node.source.value = replaceValue;
+                            }
+                        }
+                        // export * from 'x';
+                        else if (t.isExportAllDeclaration(node)) {
+                            const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                                // @ts-ignore
+                                cache: this.cache,
+                                value: node.source.value,
+                                opts,
+                                path,
+                            });
+                            if (isMatch) {
+                                node.source.value = replaceValue;
+                            }
+                        }
+                        // export { x } from 'x';
+                        else if (t.isExportNamedDeclaration(node) && node.source) {
+                            const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                                // @ts-ignore
+                                cache: this.cache,
+                                value: node.source.value,
+                                opts,
+                                path,
+                            });
+                            if (isMatch) {
+                                node.source.value = replaceValue;
+                            }
+                        }
+                        index -= 1;
+                    }
+                },
+            },
+            CallExpression: {
+                exit(path, { opts }) {
+                    const { node } = path;
+                    if (t.isImport(node.callee) &&
+                        node.arguments.length === 1 &&
+                        node.arguments[0].type === 'StringLiteral') {
+                        const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                            // @ts-ignore
+                            cache: this.cache,
+                            value: node.arguments[0].value,
+                            opts,
+                            path,
+                        });
+                        if (isMatch) {
+                            node.arguments[0] = t.stringLiteral(replaceValue);
+                        }
+                    }
+                },
+            },
+        },
+    };
+}
+exports.default = default_1;

package/dist/babelPlugins/awaitImport/checkMatch.d.ts

@@ -0,0 +1,18 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import type { IOpts } from './awaitImport';
+export declare function checkMatch({ value, path, opts, isExportAll, depth, cache, filename, }: {
+    value: string;
+    path?: Babel.NodePath;
+    opts?: IOpts;
+    isExportAll?: boolean;
+    depth?: number;
+    cache?: Map<string, any>;
+    filename?: string;
+}): {
+    isMatch: boolean;
+    replaceValue: string;
+};
+export declare function getPath({ value, opts }: {
+    value: string;
+    opts: IOpts;
+}): string;

package/dist/babelPlugins/awaitImport/checkMatch.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPath = exports.checkMatch = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const path_1 = require("path");
+const getAliasedPath_1 = require("./getAliasedPath");
+const isExternals_1 = require("./isExternals");
+// const UNMATCH_LIBS = ['umi', 'dumi', '@alipay/bigfish'];
+const RE_NODE_MODULES = /node_modules/;
+const RE_UMI_LOCAL_DEV = /umi(-next)?\/packages\//;
+function isUmiLocalDev(path) {
+    return RE_UMI_LOCAL_DEV.test((0, utils_1.winPath)(path));
+}
+function checkMatch({ value, path, opts, isExportAll, depth, cache, filename, }) {
+    var _a, _b;
+    let isMatch;
+    let replaceValue = '';
+    depth = depth || 1;
+    (0, assert_1.default)(depth <= 10, `endless loop detected in checkMatch, please check your alias config.`);
+    opts = opts || {};
+    const remoteName = opts.remoteName || 'mf';
+    // FIXME: hard code for vite mode
+    value = value.replace(/^@fs\//, '/');
+    if (
+    // unMatch specified libs
+    ((_a = opts.unMatchLibs) === null || _a === void 0 ? void 0 : _a.includes(value)) ||
+        // do not match bundler-webpack/client/client/client.js
+        value.includes('client/client/client.js') ||
+        // already handled
+        value.startsWith(`${remoteName}/`) ||
+        // don't match dynamic path
+        // e.g. @umijs/deps/compiled/babel/svgr-webpack.js?-svgo,+titleProp,+ref!./umi.svg
+        (0, utils_1.winPath)(value).includes('babel/svgr-webpack') ||
+        // don't match webpack loader
+        // e.g. !!dumi-raw-code-loader!/path/to/VerticalProgress/index.module.less?dumi-raw-code
+        value.startsWith('!!') ||
+        // don't match externals
+        (0, isExternals_1.isExternals)({ value, externals: opts.externals }) ||
+        // relative import
+        value.startsWith('.')) {
+        isMatch = false;
+    }
+    else if ((0, path_1.isAbsolute)(value)) {
+        isMatch = RE_NODE_MODULES.test(value) || isUmiLocalDev(value);
+    }
+    else {
+        const aliasedPath = (0, getAliasedPath_1.getAliasedPath)({
+            value,
+            alias: opts.alias || {},
+        });
+        if (aliasedPath) {
+            return checkMatch({
+                value: aliasedPath,
+                path,
+                opts,
+                isExportAll,
+                depth: depth + 1,
+                cache,
+                filename,
+            });
+        }
+        else {
+            isMatch = true;
+        }
+    }
+    if (isMatch && isExportAll) {
+        isMatch = !!(opts.exportAllMembers && value in opts.exportAllMembers);
+    }
+    if (isMatch) {
+        replaceValue = `${remoteName}/${(0, utils_1.winPath)(value)}`;
+    }
+    // @ts-ignore
+    const file = (path === null || path === void 0 ? void 0 : path.hub.file.opts.filename) || filename;
+    (_b = opts.onTransformDeps) === null || _b === void 0 ? void 0 : _b.call(opts, {
+        sourceValue: value,
+        replaceValue,
+        isMatch,
+        file,
+    });
+    if (cache) {
+        let mod;
+        if (cache.has(file)) {
+            mod = cache.get(file);
+        }
+        else {
+            mod = {
+                matched: new Set(),
+                unMatched: new Set(),
+            };
+            cache.set(file, mod);
+        }
+        mod[isMatch ? 'matched' : 'unMatched'].add({
+            sourceValue: value,
+            replaceValue,
+            file,
+        });
+    }
+    // console.log(
+    //   '> check',
+    //   // @ts-ignore
+    //   path.hub.file.opts.filename,
+    //   value,
+    //   cache,
+    //   'isMatch',
+    //   isMatch,
+    // );
+    return {
+        isMatch,
+        replaceValue,
+    };
+}
+exports.checkMatch = checkMatch;
+// TODO: REMOVE ME
+function getPath({ value, opts }) {
+    const alias = opts.alias || {};
+    for (const key of Object.keys(alias)) {
+        if (value.startsWith(key)) {
+            return value.replace(key, alias[key]);
+        }
+    }
+    return value;
+}
+exports.getPath = getPath;

package/dist/babelPlugins/awaitImport/getAliasedPath.d.ts

@@ -0,0 +1,4 @@
+export declare function getAliasedPath({ value, alias, }: {
+    value: string;
+    alias: Record<string, string>;
+}): string | undefined;

package/dist/babelPlugins/awaitImport/getAliasedPath.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAliasedPath = void 0;
+function getAliasedPath({ value, alias, }) {
+    const importValue = value;
+    // equal alias
+    if (alias[value]) {
+        return alias[value];
+    }
+    for (const key of Object.keys(alias)) {
+        const aliasValue = alias[key];
+        // exact alias
+        // ref: https://webpack.js.org/configuration/resolve/#resolvealias
+        // e.g. foo$: path/to/foo
+        if (key.endsWith('$')) {
+            if (importValue === key.slice(0, -1))
+                return aliasValue;
+            else
+                continue;
+        }
+        // e.g. foo: path/to/foo.js
+        if (importValue.startsWith(addLastSlash(key))) {
+            return importValue.replace(key, aliasValue);
+        }
+    }
+}
+exports.getAliasedPath = getAliasedPath;
+function addLastSlash(path) {
+    return path.endsWith('/') ? path : `${path}/`;
+}

package/dist/babelPlugins/awaitImport/getRealPath.d.ts

@@ -0,0 +1,4 @@
+export declare function getRealPath(opts: {
+    file: string;
+    dep: string;
+}): string | null;

package/dist/babelPlugins/awaitImport/getRealPath.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRealPath = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const FILE_EXT_NAMES = ['.tsx', '.ts', '.jsx', '.mjs', '.js'];
+function getRealPath(opts) {
+    const target = (0, path_1.isAbsolute)(opts.dep)
+        ? opts.dep
+        : (0, path_1.join)((0, path_1.dirname)(opts.file), opts.dep);
+    if (FILE_EXT_NAMES.includes((0, path_1.extname)(target))) {
+        return target;
+    }
+    else {
+        for (const fileExtName of FILE_EXT_NAMES) {
+            const targetWithExtName = `${target}${fileExtName}`;
+            if ((0, fs_1.existsSync)(targetWithExtName)) {
+                return targetWithExtName;
+            }
+        }
+        return null;
+    }
+}
+exports.getRealPath = getRealPath;

package/dist/babelPlugins/awaitImport/isExternals.d.ts

@@ -0,0 +1,11 @@
+declare type IExternal = Record<string, string> | Function;
+declare type IExternals = IExternal[] | IExternal;
+export declare function isExternals({ value, externals, }: {
+    value: string;
+    externals: IExternals;
+}): boolean;
+export declare function isExternal({ value, external, }: {
+    value: string;
+    external: IExternal;
+}): boolean;
+export {};

package/dist/babelPlugins/awaitImport/isExternals.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternal = exports.isExternals = void 0;
+function isExternals({ value, externals, }) {
+    const externalsArr = Array.isArray(externals) ? externals : [externals];
+    for (const external of externalsArr) {
+        if (isExternal({ value, external })) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isExternals = isExternals;
+function isExternal({ value, external, }) {
+    if (typeof external === 'object') {
+        return !!external[value];
+    }
+    else if (typeof external === 'function') {
+        let ret = false;
+        external({}, value, (_, b) => {
+            ret = !!b;
+        });
+        return ret;
+    }
+    else {
+        return false;
+    }
+}
+exports.isExternal = isExternal;

package/dist/babelPlugins/awaitImport/parseSpecifiers.d.ts

@@ -0,0 +1 @@
+export declare function parseSpecifiers(specifiers: any[]): any;

package/dist/babelPlugins/awaitImport/parseSpecifiers.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecifiers = void 0;
+const t = __importStar(require("@umijs/bundler-utils/compiled/babel/types"));
+const DEFAULT = 'default';
+function parseSpecifiers(specifiers) {
+    return specifiers.reduce((memo, s) => {
+        if (t.isImportDefaultSpecifier(s)) {
+            memo.properties.push(t.objectProperty(t.identifier(DEFAULT), s.local));
+        }
+        else if (t.isExportDefaultSpecifier(s)) {
+            memo.properties.push(t.objectProperty(t.identifier(DEFAULT), s.exported));
+        }
+        else if (t.isExportSpecifier(s)) {
+            if (t.isIdentifier(s.exported, { name: DEFAULT })) {
+                memo.defaultIdentifier = s.local.name;
+                memo.properties.push(t.objectProperty(s.local, s.local));
+            }
+            else {
+                memo.properties.push(t.objectProperty(s.local, s.exported));
+            }
+        }
+        else if (t.isImportNamespaceSpecifier(s)) {
+            memo.namespaceIdentifier = s.local;
+        }
+        else {
+            memo.properties.push(t.objectProperty(s.imported, s.local));
+        }
+        return memo;
+    }, { properties: [], namespaceIdentifier: null, defaultIdentifier: null });
+}
+exports.parseSpecifiers = parseSpecifiers;

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const MF_VA_PREFIX = "mf-va_";
+export declare const MF_DEP_PREFIX = "mf-dep_";
+export declare const MF_STATIC_PREFIX = "mf-static/";
+export declare const DEFAULT_MF_NAME = "mf";
+export declare const DEFAULT_TMP_DIR_NAME = ".mfsu";
+export declare const REMOTE_FILE = "remoteEntry.js";
+export declare const REMOTE_FILE_FULL: string;

package/dist/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOTE_FILE_FULL = exports.REMOTE_FILE = exports.DEFAULT_TMP_DIR_NAME = exports.DEFAULT_MF_NAME = exports.MF_STATIC_PREFIX = exports.MF_DEP_PREFIX = exports.MF_VA_PREFIX = void 0;
+exports.MF_VA_PREFIX = 'mf-va_';
+exports.MF_DEP_PREFIX = 'mf-dep_';
+exports.MF_STATIC_PREFIX = 'mf-static/';
+exports.DEFAULT_MF_NAME = 'mf';
+exports.DEFAULT_TMP_DIR_NAME = '.mfsu';
+exports.REMOTE_FILE = 'remoteEntry.js';
+exports.REMOTE_FILE_FULL = `${exports.MF_VA_PREFIX}${exports.REMOTE_FILE}`;

package/dist/dep/dep.d.ts

@@ -0,0 +1,30 @@
+import { MFSU } from '../mfsu';
+export declare class Dep {
+    file: string;
+    version: string;
+    cwd: string;
+    shortFile: string;
+    normalizedFile: string;
+    filePath: string;
+    mfsu: MFSU;
+    constructor(opts: {
+        file: string;
+        version: string;
+        cwd: string;
+        mfsu: MFSU;
+    });
+    buildExposeContent(): Promise<string>;
+    getRealFile(): Promise<string | null>;
+    static buildDeps(opts: {
+        deps: Record<string, {
+            file: string;
+            version: string;
+        }>;
+        cwd: string;
+        mfsu: MFSU;
+    }): Dep[];
+    static getDepVersion(opts: {
+        dep: string;
+        cwd: string;
+    }): string;
+}

package/dist/dep/dep.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dep = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const enhanced_resolve_1 = __importDefault(require("enhanced-resolve"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const trimFileContent_1 = require("../utils/trimFileContent");
+const getExposeFromContent_1 = require("./getExposeFromContent");
+const resolver = enhanced_resolve_1.default.create({
+    mainFields: ['module', 'browser', 'main'],
+    extensions: ['.js', '.json', '.mjs'],
+    exportsFields: ['exports'],
+    conditionNames: ['import', 'module', 'require', 'node'],
+});
+function resolve(context, path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            resolver(context, path, (err, result) => err ? reject(err) : resolve(result));
+        });
+    });
+}
+class Dep {
+    constructor(opts) {
+        this.file = (0, utils_1.winPath)(opts.file);
+        this.version = opts.version;
+        this.cwd = opts.cwd;
+        this.shortFile = this.file;
+        this.normalizedFile = this.shortFile.replace(/\//g, '_').replace(/:/g, '_');
+        this.filePath = `${constants_1.MF_VA_PREFIX}${this.normalizedFile}.js`;
+        this.mfsu = opts.mfsu;
+    }
+    buildExposeContent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // node natives
+            // @ts-ignore
+            const isNodeNatives = !!process.binding('natives')[this.file];
+            if (isNodeNatives) {
+                return (0, trimFileContent_1.trimFileContent)(this.mfsu.opts.excludeNodeNatives
+                    ? `
+const _ = require('${this.file}');
+module.exports = _;
+      `
+                    : `
+import _ from '${this.file}';
+export default _;
+export * from '${this.file}';
+      `);
+            }
+            // none node natives
+            const realFile = yield this.getRealFile();
+            (0, assert_1.default)(realFile, `filePath not found of ${this.file}`);
+            const content = (0, fs_1.readFileSync)(realFile, 'utf-8');
+            return yield (0, getExposeFromContent_1.getExposeFromContent)({
+                content,
+                filePath: realFile,
+                dep: this,
+            });
+        });
+    }
+    getRealFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // don't need to handle alias here
+                // it's already handled by babel plugin
+                return yield resolve(this.cwd, this.file);
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    }
+    static buildDeps(opts) {
+        return Object.keys(opts.deps).map((file) => {
+            return new Dep(Object.assign(Object.assign({}, opts.deps[file]), { cwd: opts.cwd, mfsu: opts.mfsu }));
+        });
+    }
+    static getDepVersion(opts) {
+        // @ts-ignore
+        if (!!process.binding('natives')[opts.dep]) {
+            return '*';
+        }
+        const dep = (0, path_1.isAbsolute)(opts.dep)
+            ? opts.dep
+            : (0, path_1.join)(opts.cwd, 'node_modules', opts.dep);
+        const pkg = utils_1.pkgUp.pkgUpSync({
+            cwd: dep,
+        });
+        (0, assert_1.default)(pkg, `package.json not found for ${opts.dep}`);
+        return require(pkg).version;
+    }
+}
+exports.Dep = Dep;

package/dist/dep/getCJSExports.d.ts

@@ -0,0 +1,3 @@
+export declare function getCJSExports({ content }: {
+    content: string;
+}): string[];