umi 4.0.0-rc.1 → 4.0.0-rc.10

package/bin/forkedDev.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 
-require('v8-compile-cache');
+// require('v8-compile-cache');
 require('../dist/cli/forkedDev');

package/bin/umi.js

@@ -1,6 +1,25 @@
 #!/usr/bin/env node
 
-require('v8-compile-cache');
+// disable since it's conflicted with typescript cjs + dynamic import
+// require('v8-compile-cache');
+
+// patch console for debug
+// ref: https://remysharp.com/2014/05/23/where-is-that-console-log
+if (process.env.DEBUG_CONSOLE) {
+  ['log', 'warn', 'error'].forEach((method) => {
+    const old = console[method];
+    console[method] = function () {
+      let stack = new Error().stack.split(/\n/);
+      // Chrome includes a single "Error" line, FF doesn't.
+      if (stack[0].indexOf('Error') === 0) {
+        stack = stack.slice(1);
+      }
+      const args = [].slice.apply(arguments).concat([stack[1].trim()]);
+      return old.apply(console, args);
+    };
+  });
+}
+
 require('../dist/cli/cli')
   .run()
   .catch((e) => {

package/client/client/plugin.js

@@ -52,6 +52,9 @@ export class PluginManager {
         if (args) {
             assert(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
         }
+        if (async) {
+            assert(type === ApplyPluginsType.modify || type === ApplyPluginsType.event, `async only works with modify and event type.`);
+        }
         switch (type) {
             case ApplyPluginsType.modify:
                 if (async) {
@@ -94,10 +97,15 @@ export class PluginManager {
                     }, initialValue);
                 }
             case ApplyPluginsType.event:
-                return hooks.forEach((hook) => {
-                    assert(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
-                    hook(args);
-                });
+                return (() => __awaiter(this, void 0, void 0, function* () {
+                    for (const hook of hooks) {
+                        assert(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
+                        const ret = hook(args);
+                        if (async && isPromiseLike(ret)) {
+                            yield ret;
+                        }
+                    }
+                }))();
             case ApplyPluginsType.compose:
                 return () => {
                     return compose({

package/dist/client/plugin.js

@@ -55,6 +55,9 @@ class PluginManager {
         if (args) {
             (0, utils_1.assert)(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
         }
+        if (async) {
+            (0, utils_1.assert)(type === ApplyPluginsType.modify || type === ApplyPluginsType.event, `async only works with modify and event type.`);
+        }
         switch (type) {
             case ApplyPluginsType.modify:
                 if (async) {
@@ -97,10 +100,15 @@ class PluginManager {
                     }, initialValue);
                 }
             case ApplyPluginsType.event:
-                return hooks.forEach((hook) => {
-                    (0, utils_1.assert)(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
-                    hook(args);
-                });
+                return (() => __awaiter(this, void 0, void 0, function* () {
+                    for (const hook of hooks) {
+                        (0, utils_1.assert)(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
+                        const ret = hook(args);
+                        if (async && (0, utils_1.isPromiseLike)(ret)) {
+                            yield ret;
+                        }
+                    }
+                }))();
             case ApplyPluginsType.compose:
                 return () => {
                     return (0, utils_1.compose)({

package/dist/defineConfig.d.ts

@@ -1 +1,5 @@
-export declare function defineConfig(config: any): any;
+import { IConfigFromPlugins } from '@@/core/pluginConfig';
+import type { IConfig } from '@umijs/preset-umi';
+declare type ConfigType = IConfigFromPlugins & IConfig;
+export declare function defineConfig(config: ConfigType): ConfigType;
+export {};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { IServicePluginAPI, PluginAPI } from '@umijs/core';
+export { run } from './cli/cli';
 export { defineConfig } from './defineConfig';
 export * from './service/service';
 export declare type IApi = PluginAPI & IServicePluginAPI;

package/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -10,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = void 0;
+exports.defineConfig = exports.run = void 0;
+var cli_1 = require("./cli/cli");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return cli_1.run; } });
 var defineConfig_1 = require("./defineConfig");
 Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return defineConfig_1.defineConfig; } });
 __exportStar(require("./service/service"), exports);

package/dist/pluginUtils.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/dist/test.d.ts

@@ -0,0 +1,117 @@
+import { Config } from '@umijs/test';
+export * from '@umijs/test';
+export declare function configUmiAlias(config: Config.InitialOptions): Promise<Partial<{
+    automock: boolean;
+    bail: number | boolean;
+    cache: boolean;
+    cacheDirectory: string;
+    ci: boolean;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: string[];
+    collectCoverageOnlyFrom: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: string[];
+    coverageProvider: "babel" | "v8";
+    coverageReporters: Config.CoverageReporters;
+    coverageThreshold: {
+        [path: string]: Config.CoverageThresholdValue;
+        global: Config.CoverageThresholdValue;
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | Config.DisplayName;
+    expand: boolean;
+    extensionsToTreatAsEsm: string[];
+    extraGlobals: string[];
+    filter: string;
+    findRelatedTests: boolean;
+    forceCoverageMatch: string[];
+    forceExit: boolean;
+    json: boolean;
+    globals: Config.ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: Config.HasteConfig;
+    injectGlobals: boolean;
+    reporters: (string | Config.ReporterConfig)[];
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: string | number;
+    moduleDirectories: string[];
+    moduleFileExtensions: string[];
+    moduleLoader: string;
+    moduleNameMapper: {
+        [key: string]: string | string[];
+    };
+    modulePathIgnorePatterns: string[];
+    modulePaths: string[];
+    name: string;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    outputFile: string;
+    passWithNoTests: boolean;
+    preprocessorIgnorePatterns: string[];
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: (string | Config.InitialProjectOptions)[];
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: string[];
+    runner: string;
+    runTestsByPath: boolean;
+    scriptPreprocessor: string;
+    setupFiles: string[];
+    setupTestFrameworkScriptFile: string;
+    setupFilesAfterEnv: string[];
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: string;
+    snapshotSerializers: string[];
+    snapshotFormat: Config.PrettyFormatOptions;
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: string[];
+    testNamePattern: string;
+    testPathDirs: string[];
+    testPathIgnorePatterns: string[];
+    testRegex: string | string[];
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number;
+    timers: "real" | "fake" | "modern" | "legacy";
+    transform: {
+        [regex: string]: string | Config.TransformerConfig;
+    };
+    transformIgnorePatterns: string[];
+    watchPathIgnorePatterns: string[];
+    unmockedModulePathPatterns: string[];
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean | undefined;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: (string | [string, Record<string, unknown>])[];
+}>>;

package/dist/test.js

@@ -0,0 +1,62 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configUmiAlias = void 0;
+const fs_1 = require("fs");
+const service_1 = require("./service/service");
+__exportStar(require("@umijs/test"), exports);
+function getAliasPathWithKey(alias, key) {
+    const thePath = alias[key];
+    if (alias[thePath]) {
+        return getAliasPathWithKey(alias, thePath);
+    }
+    return thePath;
+}
+let service;
+function configUmiAlias(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!service) {
+            service = new service_1.Service();
+            yield service.run2({
+                name: 'setup',
+                args: { quiet: true },
+            });
+        }
+        config.moduleNameMapper || (config.moduleNameMapper = {});
+        const { alias } = service.config;
+        for (const key of Object.keys(alias)) {
+            const aliasPath = getAliasPathWithKey(alias, key);
+            if ((0, fs_1.existsSync)(aliasPath) && (0, fs_1.statSync)(aliasPath).isDirectory()) {
+                config.moduleNameMapper[`^${key}/(.*)$`] = `${aliasPath}/$1`;
+                config.moduleNameMapper[`^${key}$`] = aliasPath;
+            }
+            else {
+                config.moduleNameMapper[`^${key}$`] = aliasPath;
+            }
+        }
+        return config;
+    });
+}
+exports.configUmiAlias = configUmiAlias;

package/index.d.ts

@@ -1,3 +1,10 @@
+// @ts-ignore
 export * from '@@/exports';
-export type { IApi } from '@umijs/preset-umi';
+export type {
+  IApi,
+  webpack,
+  IRoute,
+  UmiApiRequest,
+  UmiApiResponse,
+} from '@umijs/preset-umi';
 export * from './dist';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umi",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.10",
   "description": "umi",
   "homepage": "https://github.com/umijs/umi-next/tree/master/packages/umi#readme",
   "bugs": "https://github.com/umijs/umi-next/issues",
@@ -10,7 +10,6 @@
   },
   "license": "MIT",
   "main": "dist/index.js",
-  "module": "index.esm.js",
   "types": "index.d.ts",
   "bin": {
     "umi": "bin/umi.js"
@@ -23,20 +22,29 @@
     "bin",
     "plugin.js",
     "plugin-utils.d.ts",
-    "plugin-utils.js"
+    "plugin-utils.js",
+    "prettier.js",
+    "test.d.ts",
+    "test.js"
   ],
   "scripts": {
     "build": "pnpm tsc",
     "build:client": "pnpm tsc --project ./tsconfig.client.json",
     "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
-    "dev": "pnpm build -- --watch"
+    "dev": "pnpm build -- --watch",
+    "test": "jest -c ../../jest.turbo.config.ts"
   },
   "dependencies": {
-    "@umijs/core": "4.0.0-rc.1",
-    "@umijs/preset-umi": "4.0.0-rc.1",
-    "@umijs/renderer-react": "4.0.0-rc.1",
-    "@umijs/utils": "4.0.0-rc.1",
-    "v8-compile-cache": "2.3.0"
+    "@umijs/core": "4.0.0-rc.10",
+    "@umijs/preset-umi": "4.0.0-rc.10",
+    "@umijs/renderer-react": "4.0.0-rc.10",
+    "@umijs/test": "4.0.0-rc.10",
+    "@umijs/utils": "4.0.0-rc.10",
+    "prettier-plugin-organize-imports": "^2.3.4",
+    "prettier-plugin-packagejson": "^2.2.16"
+  },
+  "engines": {
+    "node": ">=14"
   },
   "publishConfig": {
     "access": "public"

package/prettier.js

@@ -0,0 +1,12 @@
+module.exports = {
+  printWidth: 80,
+  singleQuote: true,
+  trailingComma: 'all',
+  proseWrap: 'never',
+  endOfLine: 'lf',
+  overrides: [{ files: '.prettierrc', options: { parser: 'json' } }],
+  plugins: [
+    require.resolve('prettier-plugin-packagejson'),
+    require.resolve('prettier-plugin-organize-imports'),
+  ],
+};

package/test.d.ts

@@ -0,0 +1 @@
+export * from './dist/test';

package/test.js

@@ -0,0 +1 @@
+module.exports = require('./dist/test');