create-umi 4.0.0-beta.18 → 4.0.0-canary-20240513.3

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present ChenCheng (sorrycc@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/bin/create-umi.js

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
 
+process.env.FS_LOGGER = 'none';
 require('../dist/cli');

package/dist/cli.js

@@ -1,31 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@umijs/utils");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const args = (0, utils_1.yParser)(process.argv.slice(2), {
-    alias: {
-        version: ['v'],
-        help: ['h'],
-    },
-    boolean: ['version'],
+// src/cli.ts
+var import_utils = require("@umijs/utils");
+var args = (0, import_utils.yParser)(process.argv.slice(2), {
+  alias: {
+    version: ["v"],
+    help: ["h"]
+  },
+  boolean: ["version"]
 });
 if (args.version && !args._[0]) {
-    args._[0] = 'version';
-    const local = (0, fs_1.existsSync)((0, path_1.join)(__dirname, '../.local'))
-        ? utils_1.chalk.cyan('@local')
-        : '';
-    const { name, version } = require('../package.json');
-    console.log(`${name}@${version}${local}`);
-}
-else {
-    require('./')
-        .default({
-        cwd: process.cwd(),
-        args,
-    })
-        .catch((err) => {
-        console.error(`Create failed, ${err.message}`);
-        console.error(err);
-    });
+  args._[0] = "version";
+  const local = (0, import_utils.isLocalDev)() ? import_utils.chalk.cyan("@local") : "";
+  const { name, version } = require("../package.json");
+  console.log(`${name}@${version}${local}`);
+} else {
+  require("./").default({
+    cwd: process.cwd(),
+    args
+  }).catch((err) => {
+    console.error(`Create failed, ${err.message}`);
+    console.error(err);
+  });
 }

package/dist/index.d.ts

@@ -1,6 +1,45 @@
 import { yParser } from '@umijs/utils';
-declare const _default: ({ cwd, args, }: {
+import { type UmiTemplate } from './template';
+interface ITemplateArgs {
+    template?: UmiTemplate;
+}
+interface IArgs extends yParser.Arguments, ITemplateArgs {
+    default?: boolean;
+    git?: boolean;
+    install?: boolean;
+}
+interface ITemplatePluginParams {
+    pluginName?: string;
+}
+interface ITemplateParams extends ITemplatePluginParams {
+    version: string;
+    npmClient: ENpmClient;
+    registry: string;
+    author: string;
+    email: string;
+    withHusky: boolean;
+    extraNpmrc: string;
+}
+declare enum ENpmClient {
+    npm = "npm",
+    cnpm = "cnpm",
+    tnpm = "tnpm",
+    yarn = "yarn",
+    pnpm = "pnpm"
+}
+declare enum ETemplate {
+    app = "app",
+    max = "max",
+    vueApp = "vue-app",
+    plugin = "plugin"
+}
+export interface IDefaultData extends ITemplateParams {
+    appTemplate?: ETemplate;
+}
+interface IGeneratorOpts {
     cwd: string;
-    args: yParser.Arguments;
-}) => Promise<void>;
+    args: IArgs;
+    defaultData?: IDefaultData;
+}
+declare const _default: ({ cwd, args, defaultData, }: IGeneratorOpts) => Promise<void>;
 export default _default;

package/dist/index.js

@@ -1,106 +1,296 @@
-"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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@umijs/utils");
-const path_1 = require("path");
-const testData = {
-    name: 'umi-plugin-demo',
-    description: 'nothing',
-    mail: 'xiaohuoni@gmail.com',
-    author: 'xiaohuoni',
-    org: 'umijs',
-    version: require('../package').version,
-    npmClient: 'pnpm',
-    registry: 'https://registry.npmjs.org/',
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.default = ({ cwd, args, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const [_, name] = args._;
-    let npmClient = 'pnpm';
-    let registry = 'https://registry.npmjs.org/';
-    // test ignore prompts
-    if (!args.default) {
-        const response = yield (0, utils_1.prompts)([
-            {
-                type: 'select',
-                name: 'npmClient',
-                message: 'Pick Npm Client',
-                choices: [
-                    { title: 'npm', value: 'npm' },
-                    { title: 'cnpm', value: 'cnpm' },
-                    { title: 'tnpm', value: 'tnpm' },
-                    { title: 'yarn', value: 'yarn' },
-                    { title: 'pnpm', value: 'pnpm' },
-                ],
-                initial: 4,
-            },
-            {
-                type: 'select',
-                name: 'registry',
-                message: 'Pick Bpm Registry',
-                choices: [
-                    {
-                        title: 'npm',
-                        value: 'https://registry.npmjs.org/',
-                        selected: true,
-                    },
-                    { title: 'taobao', value: 'https://registry.npmmirror.com' },
-                ],
-            },
-        ]);
-        npmClient = response.npmClient;
-        registry = response.registry;
-    }
-    const pluginPrompts = [
-        {
-            name: 'name',
-            type: 'text',
-            message: `What's the plugin name?`,
-            default: name,
-        },
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_template = require("./template");
+var pkg = require("../package");
+var DEFAULT_DATA = {
+  pluginName: "umi-plugin-demo",
+  email: "i@domain.com",
+  author: "umijs",
+  version: pkg.version,
+  npmClient: "pnpm" /* pnpm */,
+  registry: import_template.ERegistry.npm,
+  withHusky: false,
+  extraNpmrc: "",
+  appTemplate: "app" /* app */
+};
+var src_default = async ({
+  cwd,
+  args,
+  defaultData = DEFAULT_DATA
+}) => {
+  let [name] = args._;
+  let npmClient = "pnpm" /* pnpm */;
+  let registry = import_template.ERegistry.npm;
+  let appTemplate = (defaultData == null ? void 0 : defaultData.appTemplate) || "app" /* app */;
+  const { username, email } = await (0, import_utils.getGitInfo)();
+  const author = email && username ? `${username} <${email}>` : "";
+  let pluginName = `umi-plugin-${name || "demo"}`;
+  const target = name ? (0, import_path.join)(cwd, name) : cwd;
+  const { isCancel, text, select, intro, outro } = import_utils.clackPrompts;
+  const exitPrompt = () => {
+    outro(import_utils.chalk.red("Exit create-umi"));
+    process.exit(1);
+  };
+  const selectAppTemplate = async () => {
+    appTemplate = await select({
+      message: "Pick Umi App Template",
+      options: [
+        { label: "Simple App", value: "app" /* app */ },
         {
-            name: 'description',
-            type: 'text',
-            message: `What's your plugin used for?`,
+          label: "Ant Design Pro",
+          value: "max" /* max */,
+          hint: "more plugins and ready to use features"
         },
+        { label: "Vue Simple App", value: "vue-app" /* vueApp */ },
         {
-            name: 'mail',
-            type: 'text',
-            message: `What's your email?`,
-        },
+          label: "Umi Plugin",
+          value: "plugin" /* plugin */,
+          hint: "for plugin development"
+        }
+      ],
+      initialValue: "app" /* app */
+    });
+  };
+  const selectNpmClient = async () => {
+    npmClient = await select({
+      message: "Pick Npm Client",
+      options: [
+        { label: "npm" /* npm */, value: "npm" /* npm */ },
+        { label: "cnpm" /* cnpm */, value: "cnpm" /* cnpm */ },
+        { label: "tnpm" /* tnpm */, value: "tnpm" /* tnpm */ },
+        { label: "yarn" /* yarn */, value: "yarn" /* yarn */ },
+        { label: "pnpm" /* pnpm */, value: "pnpm" /* pnpm */, hint: "recommended" }
+      ],
+      initialValue: "pnpm" /* pnpm */
+    });
+  };
+  const selectRegistry = async () => {
+    registry = await select({
+      message: "Pick Npm Registry",
+      options: [
         {
-            name: 'author',
-            type: 'text',
-            message: `What's your name?`,
+          label: "npm",
+          value: import_template.ERegistry.npm
         },
         {
-            name: 'org',
-            type: 'text',
-            message: `Which organization is your plugin stored under github?`,
-        },
-    ];
-    const generator = new utils_1.BaseGenerator({
-        path: (0, path_1.join)(__dirname, '..', 'templates', args.plugin ? 'plugin' : 'app'),
-        target: name ? (0, path_1.join)(cwd, name) : cwd,
-        data: args.default
-            ? testData
-            : {
-                version: require('../package').version,
-                npmClient,
-                registry,
-            },
-        questions: args.default ? [] : args.plugin ? pluginPrompts : [],
+          label: "taobao",
+          value: import_template.ERegistry.taobao,
+          hint: "recommended for China"
+        }
+      ],
+      initialValue: import_template.ERegistry.npm
     });
-    yield generator.run();
-    if (!args.default) {
-        // install
-        (0, utils_1.installWithNpmClient)({ npmClient });
+  };
+  const internalTemplatePrompts = async () => {
+    intro(import_utils.chalk.bgHex("#19BDD2")(" create-umi "));
+    await selectAppTemplate();
+    if (isCancel(appTemplate)) {
+      exitPrompt();
     }
-});
+    await selectNpmClient();
+    if (isCancel(npmClient)) {
+      exitPrompt();
+    }
+    await selectRegistry();
+    if (isCancel(registry)) {
+      exitPrompt();
+    }
+    const isPlugin = appTemplate === "plugin" /* plugin */;
+    if (isPlugin) {
+      pluginName = await text({
+        message: `What's the plugin name?`,
+        placeholder: pluginName,
+        validate: (value) => {
+          if (!(value == null ? void 0 : value.length)) {
+            return "Please input plugin name";
+          }
+        }
+      });
+      if (isCancel(pluginName)) {
+        exitPrompt();
+      }
+    }
+    outro(import_utils.chalk.green(`You're all set!`));
+  };
+  const useDefaultData = !!args.default;
+  const useExternalTemplate = !!args.template;
+  switch (true) {
+    case useExternalTemplate:
+      await selectNpmClient();
+      if (isCancel(npmClient)) {
+        exitPrompt();
+      }
+      await selectRegistry();
+      if (isCancel(registry)) {
+        exitPrompt();
+      }
+      await (0, import_template.unpackTemplate)({
+        template: args.template,
+        dest: target,
+        registry
+      });
+      break;
+    default:
+      if (!useDefaultData) {
+        await internalTemplatePrompts();
+      }
+  }
+  const version = pkg.version;
+  const monorepoRoot = await detectMonorepoRoot({ target });
+  const inMonorepo = !!monorepoRoot;
+  const projectRoot = inMonorepo ? monorepoRoot : target;
+  const shouldInitGit = args.git !== false;
+  const withHusky = shouldInitGit && !inMonorepo;
+  let pnpmExtraNpmrc = "";
+  const isPnpm = npmClient === "pnpm" /* pnpm */;
+  let pnpmMajorVersion;
+  let pnpmVersion;
+  if (isPnpm) {
+    pnpmVersion = await getPnpmVersion();
+    pnpmMajorVersion = parseInt(pnpmVersion.split(".")[0], 10);
+    import_utils.logger.debug(`pnpm version: ${pnpmVersion}`);
+    if (pnpmMajorVersion === 7) {
+      pnpmExtraNpmrc = `strict-peer-dependencies=false`;
+    }
+  }
+  const injectInternalTemplateFiles = async () => {
+    const generator = new import_utils.BaseGenerator({
+      path: (0, import_path.join)(__dirname, "..", "templates", appTemplate),
+      target,
+      slient: true,
+      data: useDefaultData ? defaultData : {
+        version: version.includes("-canary.") ? version : `^${version}`,
+        npmClient,
+        registry,
+        author,
+        email,
+        withHusky,
+        extraNpmrc: isPnpm ? pnpmExtraNpmrc : "",
+        pluginName
+      }
+    });
+    await generator.run();
+  };
+  if (!useExternalTemplate) {
+    await injectInternalTemplateFiles();
+  }
+  const context = {
+    inMonorepo,
+    target,
+    projectRoot
+  };
+  if (!withHusky) {
+    await removeHusky(context);
+  }
+  if (inMonorepo) {
+    await moveNpmrc(context);
+  }
+  if (shouldInitGit) {
+    await initGit(context);
+  } else {
+    import_utils.logger.info(`Skip Git init`);
+  }
+  const isPnpm8 = pnpmMajorVersion === 8;
+  const pnpmHighestResolutionMinVersion = "8.7.0";
+  const isPnpmHighestResolution = isPnpm8 && import_utils.semver.gte(pnpmVersion, pnpmHighestResolutionMinVersion);
+  if (!useDefaultData && args.install !== false) {
+    if (isPnpm8 && !isPnpmHighestResolution) {
+      await installAndUpdateWithPnpm(target);
+    } else {
+      (0, import_utils.installWithNpmClient)({ npmClient, cwd: target });
+    }
+  } else {
+    import_utils.logger.info(`Skip install deps`);
+    if (isPnpm8) {
+      import_utils.logger.warn(
+        import_utils.chalk.yellow(
+          `You current using pnpm v8, it will install minimal version of dependencies`
+        )
+      );
+      import_utils.logger.warn(
+        import_utils.chalk.green(
+          `Recommended that you run ${import_utils.chalk.bold.cyan(
+            "pnpm up -L"
+          )} to install latest version of dependencies`
+        )
+      );
+    }
+  }
+};
+async function detectMonorepoRoot(opts) {
+  const { target } = opts;
+  const rootPkg = await import_utils.pkgUp.pkgUp({ cwd: (0, import_path.dirname)(target) });
+  if (!rootPkg) {
+    return null;
+  }
+  const rootDir = (0, import_path.dirname)(rootPkg);
+  if ((0, import_utils.tryPaths)([
+    (0, import_path.join)(rootDir, "lerna.json"),
+    (0, import_path.join)(rootDir, "pnpm-workspace.yaml")
+  ])) {
+    return rootDir;
+  }
+  return null;
+}
+async function moveNpmrc(opts) {
+  const { target, projectRoot } = opts;
+  const sourceNpmrc = (0, import_path.join)(target, "./.npmrc");
+  const targetNpmrc = (0, import_path.join)(projectRoot, "./.npmrc");
+  if (!(0, import_fs.existsSync)(targetNpmrc)) {
+    await import_utils.fsExtra.copyFile(sourceNpmrc, targetNpmrc);
+  }
+  await import_utils.fsExtra.remove(sourceNpmrc);
+}
+async function initGit(opts) {
+  const { projectRoot } = opts;
+  const isGit = (0, import_fs.existsSync)((0, import_path.join)(projectRoot, ".git"));
+  if (isGit)
+    return;
+  try {
+    await import_utils.execa.execa("git", ["init"], { cwd: projectRoot });
+  } catch {
+    import_utils.logger.error(`Initial the git repo failed`);
+  }
+}
+async function removeHusky(opts) {
+  const dir = (0, import_path.join)(opts.target, "./.husky");
+  if ((0, import_fs.existsSync)(dir)) {
+    await import_utils.fsExtra.remove(dir);
+  }
+}
+async function installAndUpdateWithPnpm(cwd) {
+  await import_utils.execa.execa("pnpm", ["up", "-L"], { cwd, stdio: "inherit" });
+}
+async function getPnpmVersion() {
+  try {
+    const { stdout } = await import_utils.execa.execa("pnpm", ["--version"]);
+    return stdout.trim();
+  } catch (e) {
+    throw new Error("Please install pnpm first", { cause: e });
+  }
+}

package/dist/template.d.ts

@@ -0,0 +1,12 @@
+export declare enum ERegistry {
+    npm = "https://registry.npmjs.com/",
+    taobao = "https://registry.npmmirror.com/"
+}
+export declare type UmiTemplate = `@umijs/${string}-template`;
+interface IUnpackTemplateOpts {
+    template: UmiTemplate;
+    dest: string;
+    registry: ERegistry;
+}
+export declare const unpackTemplate: (opts: IUnpackTemplateOpts) => Promise<string>;
+export {};

package/dist/template.js

@@ -0,0 +1,113 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/template.ts
+var template_exports = {};
+__export(template_exports, {
+  ERegistry: () => ERegistry,
+  unpackTemplate: () => unpackTemplate
+});
+module.exports = __toCommonJS(template_exports);
+var import_utils = require("@umijs/utils");
+var import_tar = require("@umijs/utils/compiled/tar");
+var ERegistry = /* @__PURE__ */ ((ERegistry2) => {
+  ERegistry2["npm"] = "https://registry.npmjs.com/";
+  ERegistry2["taobao"] = "https://registry.npmmirror.com/";
+  return ERegistry2;
+})(ERegistry || {});
+var unpackTemplate = async (opts) => {
+  const { template, dest, registry } = opts;
+  import_utils.logger.info(
+    `Init a new project with template ${import_utils.chalk.blue(template)} from npm ...`
+  );
+  const tryDownload = async (name) => {
+    const url = await getNpmPkgTarUrl({ registry, name });
+    if (!url) {
+      return;
+    }
+    try {
+      return await downloadTar({ dest, url });
+    } catch (e) {
+      throw new Error(`Download ${name} failed from ${registry}`, { cause: e });
+    }
+  };
+  const nameList = [];
+  const isStartWithUmi = template.startsWith("@umijs/");
+  if (template.endsWith("-template")) {
+    if (isStartWithUmi) {
+      nameList.push(template);
+    } else {
+      nameList.push(`@umijs/${template}`);
+    }
+  } else if (isStartWithUmi) {
+    nameList.push(`${template}-template`);
+  } else {
+    nameList.push(`@umijs/${template}-template`);
+  }
+  for await (const name of nameList) {
+    const success = await tryDownload(name);
+    if (success) {
+      import_utils.logger.ready(`Init ${import_utils.chalk.green(name)} success`);
+      return success;
+    }
+  }
+  throw new Error(
+    `Template ${nameList.map((i) => import_utils.chalk.yellow(i)).join(", ")} not found from ${registry}`
+  );
+};
+async function getNpmPkgTarUrl(opts) {
+  var _a;
+  const { registry, name } = opts;
+  const nameWithoutScope = name.startsWith("@") ? name.split("/")[1] : name;
+  const latestPkgInfoUrl = `${registry}${name}/latest`;
+  const res = await import_utils.axios.get(latestPkgInfoUrl, { validateStatus: () => true });
+  const latestVersion = (_a = res == null ? void 0 : res.data) == null ? void 0 : _a.version;
+  if (!latestVersion) {
+    return;
+  }
+  const latestTarUrl = `${registry}${name}/-/${nameWithoutScope}-${latestVersion}.tgz`;
+  return latestTarUrl;
+}
+async function downloadTar(opts) {
+  const { dest, url } = opts;
+  return new Promise(async (resolve, reject) => {
+    try {
+      const res = await import_utils.axios.get(url, {
+        responseType: "stream"
+      });
+      import_utils.fsExtra.mkdirpSync(dest);
+      res.data.pipe(
+        (0, import_tar.x)({
+          C: dest,
+          strip: 1
+        })
+      );
+      resolve(dest);
+    } catch (e) {
+      if (import_utils.fsExtra.existsSync(dest)) {
+        import_utils.fsExtra.removeSync(dest);
+      }
+      reject(e);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERegistry,
+  unpackTemplate
+});