@umijs/preset-umi 4.0.0-beta.10

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => {
+    return {
+        plugins: [
+            // registerMethods
+            require.resolve('./registerMethods'),
+            // features
+            require.resolve('./features/appData/appData'),
+            require.resolve('./features/check/check'),
+            require.resolve('./features/configPlugins/configPlugins'),
+            require.resolve('./features/esmi/esmi'),
+            require.resolve('./features/favicon/favicon'),
+            require.resolve('./features/mock/mock'),
+            require.resolve('./features/polyfill/polyfill'),
+            require.resolve('./features/tmpFiles/tmpFiles'),
+            require.resolve('./features/transform/transform'),
+            // commands
+            require.resolve('./commands/build'),
+            require.resolve('./commands/config/config'),
+            require.resolve('./commands/dev/dev'),
+            require.resolve('./commands/help'),
+            require.resolve('./commands/setup'),
+            require.resolve('./commands/version'),
+            require.resolve('./commands/generate/page'),
+            require.resolve('./commands/generate/prettier'),
+            require.resolve('./commands/plugin'),
+        ],
+    };
+};

package/dist/libs/moduleGraph.d.ts

@@ -0,0 +1,2 @@
+export declare class ModuleGraph {
+}

package/dist/libs/moduleGraph.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleGraph = void 0;
+class ModuleGraph {
+}
+exports.ModuleGraph = ModuleGraph;

package/dist/libs/scan.d.ts

@@ -0,0 +1,28 @@
+declare enum ImportType {
+    import = "import",
+    dynamicImport = "dynamicImport",
+    export = "export"
+}
+interface Dep {
+    url: string;
+    importType: ImportType;
+    specifiers?: 'namespace' | string[];
+}
+export declare function scanContent(opts: {
+    content: string;
+    needDepSpecifier?: boolean;
+}): Promise<{
+    deps: Dep[];
+}>;
+export declare function getContent(path: string): Promise<string>;
+export declare function createResolver(opts: {
+    alias: any;
+}): {
+    resolve: (context: string, path: string) => Promise<string>;
+};
+export declare function scan(opts: {
+    entry: string;
+    externals: any;
+    resolver: any;
+}): Promise<Record<string, string>>;
+export {};

package/dist/libs/scan.js

@@ -0,0 +1,110 @@
+"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.scan = exports.createResolver = exports.getContent = exports.scanContent = void 0;
+const es_module_lexer_1 = require("@umijs/bundler-utils/compiled/es-module-lexer");
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+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");
+var ImportType;
+(function (ImportType) {
+    ImportType["import"] = "import";
+    ImportType["dynamicImport"] = "dynamicImport";
+    ImportType["export"] = "export";
+})(ImportType || (ImportType = {}));
+// 项目文件都是 esm，无需考虑 cjs
+function scanContent(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield es_module_lexer_1.init;
+        const [imports] = (0, es_module_lexer_1.parse)(opts.content);
+        const deps = imports.map((imp) => {
+            let importType = ImportType.import;
+            if (imp.d > -1)
+                importType = ImportType.dynamicImport;
+            if (opts.content.slice(imp.ss, imp.se).startsWith('export ')) {
+                importType = ImportType.export;
+            }
+            return {
+                url: imp.n,
+                importType,
+            };
+        });
+        return { deps };
+    });
+}
+exports.scanContent = scanContent;
+function getContent(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let content = (0, fs_1.readFileSync)(path, 'utf-8');
+        // es-module-lexer don't support jsx
+        if (path.endsWith('.tsx') || path.endsWith('.jsx')) {
+            content = (0, esbuild_1.transformSync)(content, {
+                loader: (0, path_1.extname)(path).slice(1),
+                format: 'esm',
+            }).code;
+        }
+        return content;
+    });
+}
+exports.getContent = getContent;
+function createResolver(opts) {
+    const resolver = enhanced_resolve_1.default.create({
+        mainFields: ['module', 'browser', 'main'],
+        extensions: ['.js', '.json', '.mjs', '.ts', '.tsx'],
+        exportsFields: [],
+        alias: opts.alias,
+    });
+    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));
+            });
+        });
+    }
+    return { resolve };
+}
+exports.createResolver = createResolver;
+function scan(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cache = new Map();
+        const queueDeps = [opts.entry];
+        const ret = {};
+        while (queueDeps.length) {
+            const depPath = queueDeps.shift();
+            if (cache.has(depPath))
+                continue;
+            const content = yield getContent(depPath);
+            const { deps } = yield scanContent({ content });
+            cache.set(depPath, deps);
+            for (const dep of deps) {
+                const resolved = yield opts.resolver.resolve((0, path_1.dirname)(depPath), dep.url);
+                if (resolved.includes('node_modules') ||
+                    resolved.includes('umi-next/packages')) {
+                    const pkgPath = utils_1.pkgUp.sync({ cwd: resolved });
+                    (0, assert_1.default)(pkgPath, `package.json for found for ${resolved}`);
+                    const pkg = require(pkgPath);
+                    ret[pkg.name] = pkg.version;
+                }
+                else if (['.ts', '.tsx', '.js', '.jsx', '.mjs'].includes((0, path_1.extname)(resolved))) {
+                    queueDeps.push(resolved);
+                }
+            }
+        }
+        return ret;
+    });
+}
+exports.scan = scan;

package/dist/registerMethods.d.ts

@@ -0,0 +1,3 @@
+import { IApi } from './types';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/registerMethods.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const isTypeScriptFile_1 = require("./utils/isTypeScriptFile");
+exports.default = (api) => {
+    [
+        'onGenerateFiles',
+        'onBeforeCompiler',
+        'onBuildComplete',
+        // 'onPatchRoute',
+        // 'onPatchRouteBefore',
+        // 'onPatchRoutes',
+        // 'onPatchRoutesBefore',
+        'onPkgJSONChanged',
+        'onDevCompileDone',
+        'onCheckPkgJSON',
+        'onCheckCode',
+        'onCheckConfig',
+        'addBeforeMiddlewares',
+        'addLayouts',
+        'addMiddlewares',
+        'addRuntimePlugin',
+        'addRuntimePluginKey',
+        // 'addUmiExports',
+        'addPolyfillImports',
+        'addEntryImportsAhead',
+        'addEntryImports',
+        'addEntryCodeAhead',
+        'addEntryCode',
+        'addExtraBabelPresets',
+        'addExtraBabelPlugins',
+        'addBeforeBabelPresets',
+        'addBeforeBabelPlugins',
+        'addHTMLMetas',
+        'addHTMLLinks',
+        'addHTMLStyles',
+        'addHTMLHeadScripts',
+        'addHTMLScripts',
+        'addTmpGenerateWatcherPaths',
+        'chainWebpack',
+        'modifyHTMLFavicon',
+        'modifyHTML',
+        'modifyWebpackConfig',
+        'modifyViteConfig',
+        // 'modifyHTMLChunks',
+        // 'modifyExportRouteMap',
+        // 'modifyPublicPathStr',
+        'modifyRendererPath',
+        // 'modifyRoutes',
+    ].forEach((name) => {
+        api.registerMethod({ name });
+    });
+    api.registerMethod({
+        name: 'writeTmpFile',
+        fn(opts) {
+            (0, assert_1.default)(api.service.stage >= api.ServiceStage.runCommand, `api.writeTmpFile() should not execute in register stage.`);
+            const absPath = (0, path_1.join)(api.paths.absTmpPath, opts.path);
+            utils_1.fsExtra.mkdirpSync((0, path_1.dirname)(absPath));
+            let content = opts.content;
+            if (!content) {
+                (0, assert_1.default)(!opts.tplPath ||
+                    ((0, fs_1.existsSync)(opts.tplPath) && (0, fs_1.statSync)(opts.tplPath).isFile()), `opts.tplPath does not exists or is not a file.`);
+                const tpl = opts.tplPath
+                    ? (0, fs_1.readFileSync)(opts.tplPath, 'utf-8')
+                    : opts.tpl;
+                (0, assert_1.default)(tpl, `opts.tpl or opts.tplPath must be supplied.`);
+                (0, assert_1.default)(utils_1.lodash.isPlainObject(opts.context), `opts.context must be plain object.`);
+                content = utils_1.Mustache.render(tpl, opts.context);
+            }
+            content = [
+                (0, isTypeScriptFile_1.isTypeScriptFile)(opts.path) && `// @ts-nocheck`,
+                '// This file is generated by Umi automatically',
+                '// DO NOT CHANGE IT MANUALLY!',
+                content,
+            ]
+                .filter((text) => text !== false)
+                .join('\n');
+            if (!(0, fs_1.existsSync)(absPath) || (0, fs_1.readFileSync)(absPath, 'utf-8') !== content) {
+                (0, fs_1.writeFileSync)(absPath, content, 'utf-8');
+            }
+        },
+    });
+};

package/dist/types.d.ts

@@ -0,0 +1,147 @@
+import type { RequestHandler } from '@umijs/bundler-webpack';
+import type webpack from '@umijs/bundler-webpack/compiled/webpack';
+import type WebpackChain from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import type { IAdd, IEvent, IModify, IRoute as ICoreRoute, IServicePluginAPI, PluginAPI } from '@umijs/core';
+import { Env } from '@umijs/core';
+import type { CheerioAPI } from '@umijs/utils/compiled/cheerio';
+export declare type IScript = Partial<{
+    async: boolean;
+    charset: string;
+    crossOrigin: string | null;
+    defer: boolean;
+    src: string;
+    type: string;
+    content: string;
+}> | string;
+export declare type IStyle = Partial<{
+    type: string;
+    content: string;
+}> | string;
+export declare type ILink = Partial<{
+    as: string;
+    crossOrigin: string | null;
+    disabled: boolean;
+    href: string;
+    hreflang: string;
+    imageSizes: string;
+    imageSrcset: string;
+    integrity: string;
+    media: string;
+    referrerPolicy: string;
+    rel: string;
+    rev: string;
+    target: string;
+    type: string;
+}>;
+export declare type IMeta = Partial<{
+    content: string;
+    httpEquiv: string;
+    name: string;
+    scheme: string;
+}>;
+export declare type IEntryImport = {
+    source: string;
+    specifier?: string;
+};
+export declare type IRoute = ICoreRoute;
+export declare type IApi = PluginAPI & IServicePluginAPI & {
+    restartServer: () => void;
+    writeTmpFile: (opts: {
+        path: string;
+        content?: string;
+        tpl?: string;
+        tplPath?: string;
+        context?: Record<string, any>;
+    }) => void;
+    addTmpGenerateWatcherPaths: IAdd<null, string[]>;
+    onGenerateFiles: IEvent<{
+        isFirstTime?: boolean;
+        files?: {
+            event: string;
+            path: string;
+        } | null;
+    }>;
+    onPkgJSONChanged: IEvent<{
+        origin: Record<string, any>;
+        current: Record<string, any>;
+    }>;
+    onBeforeCompiler: IEvent<{}>;
+    onBuildComplete: IEvent<{
+        isFirstCompile: boolean;
+        stats: any;
+        time: number;
+        err?: Error;
+    }>;
+    onCheckPkgJSON: IEvent<{
+        origin?: Record<string, any>;
+        current: Record<string, any>;
+    }>;
+    onCheckConfig: IEvent<{
+        config: Record<string, any>;
+        userConfig: Record<string, any>;
+    }>;
+    onCheckCode: IEvent<{
+        file: string;
+        code: string;
+        isFromTmp: boolean;
+        imports: {
+            source: string;
+            loc: any;
+            default: string;
+            namespace: string;
+            specifiers: Record<string, string>;
+        }[];
+        exports: any[];
+        cjsExports: string[];
+    }>;
+    onDevCompileDone: IEvent<{
+        isFirstCompile: boolean;
+        stats: any;
+        time: number;
+    }>;
+    addEntryImports: IAdd<null, IEntryImport[]>;
+    addEntryImportsAhead: IAdd<null, IEntryImport[]>;
+    addEntryCodeAhead: IAdd<null, string[]>;
+    addEntryCode: IAdd<null, string[]>;
+    addExtraBabelPresets: IAdd<null, any[]>;
+    addExtraBabelPlugins: IAdd<null, any[]>;
+    addBeforeBabelPresets: IAdd<null, any[]>;
+    addBeforeBabelPlugins: IAdd<null, any[]>;
+    addBeforeMiddlewares: IAdd<null, RequestHandler[]>;
+    addMiddlewares: IAdd<null, RequestHandler[]>;
+    addHTMLHeadScripts: IAdd<null, IScript[]>;
+    addHTMLScripts: IAdd<null, IScript[]>;
+    addHTMLStyles: IAdd<null, IStyle[]>;
+    addHTMLLinks: IAdd<null, ILink[]>;
+    addHTMLMetas: IAdd<null, IMeta[]>;
+    addLayouts: IAdd<null, {
+        id: string;
+        file: string;
+    }[]>;
+    addPolyfillImports: IAdd<null, {
+        source: string;
+        specifier?: string;
+    }[]>;
+    addRuntimePlugin: IAdd<null, string[]>;
+    addRuntimePluginKey: IAdd<null, string[]>;
+    modifyHTMLFavicon: IModify<string, {}>;
+    modifyHTML: IModify<CheerioAPI, {
+        path: string;
+    }>;
+    modifyRendererPath: IModify<string, {}>;
+    modifyWebpackConfig: IModify<webpack.Configuration, {
+        webpack: typeof webpack;
+        env: Env;
+    }>;
+    modifyViteConfig: IModify<webpack.Configuration, {
+        env: Env;
+    }>;
+    chainWebpack: {
+        (fn: {
+            (memo: WebpackChain, args: {
+                webpack: typeof webpack;
+                env: Env;
+            }): void;
+        }): void;
+    };
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/clearTmp.d.ts

@@ -0,0 +1 @@
+export declare function clearTmp(absTmpPath: string): void;

package/dist/utils/clearTmp.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTmp = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+function clearTmp(absTmpPath) {
+    if (!(0, fs_1.existsSync)(absTmpPath))
+        return;
+    (0, fs_1.readdirSync)(absTmpPath).forEach((file) => {
+        if (file === constants_1.CACHE_DIR_NAME)
+            return;
+        utils_1.rimraf.sync((0, path_1.join)(absTmpPath, file));
+    });
+}
+exports.clearTmp = clearTmp;

package/dist/utils/isTypeScriptFile.d.ts

@@ -0,0 +1 @@
+export declare function isTypeScriptFile(path: string): boolean;

package/dist/utils/isTypeScriptFile.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeScriptFile = void 0;
+function isTypeScriptFile(path) {
+    return !/\.d\.ts$/.test(path) && /\.(ts|tsx)$/.test(path);
+}
+exports.isTypeScriptFile = isTypeScriptFile;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@umijs/preset-umi",
+  "version": "4.0.0-beta.10",
+  "description": "@umijs/preset-umi",
+  "homepage": "https://github.com/umijs/umi-next/tree/master/packages/preset-umi#readme",
+  "bugs": "https://github.com/umijs/umi-next/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umijs/umi-next"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "assets",
+    "dist",
+    "templates",
+    "compiled"
+  ],
+  "scripts": {
+    "build": "pnpm tsc",
+    "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
+    "dev": "pnpm build -- --watch"
+  },
+  "dependencies": {
+    "@types/multer": "1.4.7",
+    "@umijs/ast": "4.0.0-beta.10",
+    "@umijs/babel-preset-umi": "4.0.0-beta.10",
+    "@umijs/bundler-utils": "4.0.0-beta.10",
+    "@umijs/bundler-vite": "4.0.0-beta.10",
+    "@umijs/bundler-webpack": "4.0.0-beta.10",
+    "@umijs/core": "4.0.0-beta.10",
+    "@umijs/renderer-react": "4.0.0-beta.10",
+    "@umijs/server": "4.0.0-beta.10",
+    "@umijs/utils": "4.0.0-beta.10",
+    "current-script-polyfill": "1.0.0",
+    "enhanced-resolve": "5.8.3",
+    "path-to-regexp": "1.7.0",
+    "react": "18.0.0-alpha-f2c381131-20211004",
+    "react-dom": "18.0.0-alpha-f2c381131-20211004",
+    "react-router": "6.0.0-beta.7",
+    "react-router-dom": "6.0.0-beta.7"
+  },
+  "devDependencies": {
+    "@types/body-parser": "1.19.2",
+    "@types/multer": "1.4.7",
+    "body-parser": "1.19.0",
+    "multer": "1.4.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "chencheng <sorrycc@gmail.com> (https://github.com/sorrycc)"
+  ],
+  "compiledConfig": {
+    "deps": [
+      "body-parser",
+      "multer"
+    ]
+  }
+}

package/templates/generate/page/index.less.tpl

@@ -0,0 +1,4 @@
+
+.title {
+  background: {{{ color }}};
+}

package/templates/generate/page/index.tsx.tpl

@@ -0,0 +1,10 @@
+import React from 'react';
+import styles from './{{{ name }}}{{{ cssExt }}}';
+
+export default function Page() {
+  return (
+    <div>
+      <h1 className={styles.title}>Page {{{ name }}}</h1>
+    </div>
+  );
+}

package/templates/plugin.tpl

@@ -0,0 +1,18 @@
+{{#plugins}}
+import * as Plugin_{{{ index }}} from '{{{ path }}}';
+{{/plugins}}
+
+export function getPlugins() {
+  return [
+{{#plugins}}
+    {
+      apply: Plugin_{{{ index }}},
+      path: '{{{ path }}}',
+    },
+{{/plugins}}
+  ];
+}
+
+export function getValidKeys() {
+  return [{{#validKeys}}'{{{ . }}}',{{/validKeys}}];
+}

package/templates/route.tpl

@@ -0,0 +1,7 @@
+
+export async function getRoutes() {
+  return {
+    routes: {{{ routes }}},
+    routeComponents: {{{ routeComponents }}},
+  };
+}

package/templates/umi.tpl

@@ -0,0 +1,22 @@
+{{{ polyfillImports }}}
+{{{ importsAhead }}}
+import { renderClient } from '{{{ rendererPath }}}';
+import { getRoutes } from './core/route';
+import { getPlugins, getValidKeys } from './core/plugin';
+import { PluginManager } from 'umi';
+{{{ imports }}}
+
+async function render() {
+  const context = {
+    ...await getRoutes(),
+    pluginManager: PluginManager.create({
+      plugins: getPlugins(),
+      validKeys: getValidKeys(),
+    }),
+  };
+  return renderClient(context);
+}
+
+{{{ entryCodeAhead }}}
+render();
+{{{ entryCode }}}