@4399ywkf/core 4.0.61

package/dist/service/env.js

@@ -0,0 +1,46 @@
+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/service/env.ts
+var env_exports = {};
+__export(env_exports, {
+  loadEnv: () => loadEnv
+});
+module.exports = __toCommonJS(env_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_dotenv = require("../../compiled/dotenv");
+var import_dotenv_expand = require("../../compiled/dotenv-expand");
+function loadEnv(opts) {
+  const files = [
+    (0, import_path.join)(opts.cwd, opts.envFile),
+    (0, import_path.join)(opts.cwd, `${opts.envFile}.local`)
+  ];
+  for (const file of files) {
+    if (!(0, import_fs.existsSync)(file)) continue;
+    const parsed = (0, import_dotenv.parse)((0, import_fs.readFileSync)(file)) || {};
+    (0, import_dotenv_expand.expand)({ parsed, ignoreProcessEnv: true });
+    for (const key of Object.keys(parsed)) {
+      process.env[key] = parsed[key];
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadEnv
+});

package/dist/service/generatePlugin.d.ts

@@ -0,0 +1,4 @@
+import { PluginAPI } from './pluginAPI';
+import { IServicePluginAPI } from './service';
+declare const _default: (api: PluginAPI & IServicePluginAPI) => void;
+export default _default;

package/dist/service/generatePlugin.js

@@ -0,0 +1,102 @@
+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/service/generatePlugin.ts
+var generatePlugin_exports = {};
+__export(generatePlugin_exports, {
+  default: () => generatePlugin_default
+});
+module.exports = __toCommonJS(generatePlugin_exports);
+var import_utils = require("@4399ywkf/utils");
+var import_generator = require("./generator");
+var generatePlugin_default = (api) => {
+  api.registerCommand({
+    name: "generate",
+    alias: "g",
+    details: `
+umi generate
+`,
+    description: "generate code snippets quickly",
+    configResolveMode: "loose",
+    async fn({ args }) {
+      var _a;
+      const [type] = args._;
+      const runGenerator = async (generator) => {
+        await (generator == null ? void 0 : generator.fn({
+          args,
+          generateFile: import_utils.generateFile,
+          installDeps: import_utils.installDeps,
+          updatePackageJSON: import_utils.updatePackageJSON
+        }));
+      };
+      if (type) {
+        const generator = api.service.generators[type];
+        if (!generator) {
+          throw new Error(`Generator ${type} not found.`);
+        }
+        if (generator.type === import_generator.GeneratorType.enable) {
+          const enable = await ((_a = generator.checkEnable) == null ? void 0 : _a.call(generator, {
+            args
+          }));
+          if (!enable) {
+            if (typeof generator.disabledDescription === "function") {
+              import_utils.logger.warn(generator.disabledDescription());
+            } else {
+              import_utils.logger.warn(generator.disabledDescription);
+            }
+            return;
+          }
+        }
+        await runGenerator(generator);
+      } else {
+        const getEnableGenerators = async (generators) => {
+          var _a2;
+          const questions2 = [];
+          for (const key of Object.keys(generators)) {
+            const g = generators[key];
+            if (g.type === import_generator.GeneratorType.generate) {
+              questions2.push({
+                title: `${g.name} -- ${g.description}` || "",
+                value: g.key
+              });
+            } else {
+              const enable = await ((_a2 = g == null ? void 0 : g.checkEnable) == null ? void 0 : _a2.call(g, {
+                args
+              }));
+              if (enable) {
+                questions2.push({
+                  title: `${g.name} -- ${g.description}` || "",
+                  value: g.key
+                });
+              }
+            }
+          }
+          return questions2;
+        };
+        const questions = await getEnableGenerators(api.service.generators);
+        const { gType } = await (0, import_utils.prompts)({
+          type: "select",
+          name: "gType",
+          message: "Pick generator type",
+          choices: questions
+        });
+        await runGenerator(api.service.generators[gType]);
+      }
+    }
+  });
+};

package/dist/service/generator.d.ts

@@ -0,0 +1,71 @@
+import { generateFile } from '@4399ywkf/utils';
+import { Plugin } from './plugin';
+export declare enum GeneratorType {
+    generate = "generate",
+    enable = "enable"
+}
+declare type IGeneratorOptsWithoutEnableCheck = {
+    key: string;
+    name: string;
+    description: string;
+    type: GeneratorType.generate;
+    fn: {
+        (opts: {
+            args: any;
+            generateFile: typeof generateFile;
+            updatePackageJSON: {
+                (opts: {
+                    opts: object;
+                    cwd?: string;
+                }): void;
+            };
+            installDeps: {
+                (opts: {
+                    opts: {
+                        devDependencies?: string[];
+                        dependencies?: string[];
+                    };
+                    cwd?: string;
+                }): void;
+            };
+        }): void;
+    };
+    plugin: Plugin;
+};
+declare type IGeneratorOptsWithEnableCheck = {
+    key: string;
+    name: string;
+    description: string;
+    type: GeneratorType.enable;
+    checkEnable: {
+        (opts: {
+            args: any;
+        }): boolean;
+    };
+    disabledDescription: string | (() => string);
+    fn: {
+        (opts: {
+            args: any;
+            generateFile: typeof generateFile;
+            updatePackageJSON: {
+                (opts: {
+                    opts: object;
+                    cwd?: string;
+                }): void;
+            };
+            installDeps: {
+                (opts: {
+                    opts: {
+                        devDependencies?: string[];
+                        dependencies?: string[];
+                    };
+                    cwd?: string;
+                }): void;
+            };
+        }): void;
+    };
+    plugin: Plugin;
+};
+export declare type Generator = IGeneratorOptsWithEnableCheck | IGeneratorOptsWithoutEnableCheck;
+export declare function makeGenerator<T>(opts: T): T;
+export {};

package/dist/service/generator.js

@@ -0,0 +1,40 @@
+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/service/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  GeneratorType: () => GeneratorType,
+  makeGenerator: () => makeGenerator
+});
+module.exports = __toCommonJS(generator_exports);
+var GeneratorType = /* @__PURE__ */ ((GeneratorType2) => {
+  GeneratorType2["generate"] = "generate";
+  GeneratorType2["enable"] = "enable";
+  return GeneratorType2;
+})(GeneratorType || {});
+function makeGenerator(opts) {
+  return {
+    ...opts
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GeneratorType,
+  makeGenerator
+});

package/dist/service/hook.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from './plugin';
+export interface IOpts {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+}
+export declare class Hook {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+    constructor(opts: IOpts);
+}

package/dist/service/hook.js

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/service/hook.ts
+var hook_exports = {};
+__export(hook_exports, {
+  Hook: () => Hook
+});
+module.exports = __toCommonJS(hook_exports);
+var import_assert = __toESM(require("assert"));
+var Hook = class {
+  plugin;
+  key;
+  fn;
+  before;
+  stage;
+  constructor(opts) {
+    (0, import_assert.default)(
+      opts.key && opts.fn,
+      `Invalid hook ${opts}, key and fn must supplied.`
+    );
+    this.plugin = opts.plugin;
+    this.key = opts.key;
+    this.fn = opts.fn;
+    this.before = opts.before;
+    this.stage = opts.stage || 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hook
+});

package/dist/service/path.d.ts

@@ -0,0 +1,15 @@
+import { Env } from '../types';
+export declare function getPaths(opts: {
+    cwd: string;
+    prefix: string;
+    env: Env;
+}): {
+    cwd: string;
+    absSrcPath: string;
+    absPagesPath: string;
+    absApiRoutesPath: string;
+    absTmpPath: string;
+    absNodeModulesPath: string;
+    absOutputPath: string;
+};
+export declare type Paths = ReturnType<typeof getPaths>;

package/dist/service/path.js

@@ -0,0 +1,55 @@
+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/service/path.ts
+var path_exports = {};
+__export(path_exports, {
+  getPaths: () => getPaths
+});
+module.exports = __toCommonJS(path_exports);
+var import_utils = require("@4399ywkf/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_types = require("../types");
+function winJoin(...args) {
+  return (0, import_utils.winPath)((0, import_path.join)(...args));
+}
+function getPaths(opts) {
+  const cwd = opts.cwd;
+  const src = winJoin(cwd, "src");
+  const absSrcPath = (0, import_fs.existsSync)(src) && (0, import_fs.statSync)(src).isDirectory() ? src : cwd;
+  const absPagesPath = winJoin(absSrcPath, "pages");
+  const absApiRoutesPath = winJoin(absSrcPath, "api");
+  const tmp = opts.env === import_types.Env.development ? `.${opts.prefix}` : `.${opts.prefix}-${opts.env}`;
+  const absTmpPath = winJoin(absSrcPath, tmp);
+  const absNodeModulesPath = winJoin(cwd, "node_modules");
+  const absOutputPath = winJoin(cwd, "dist");
+  return {
+    cwd,
+    absSrcPath,
+    absPagesPath,
+    absApiRoutesPath,
+    absTmpPath,
+    absNodeModulesPath,
+    absOutputPath
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPaths
+});

package/dist/service/plugin.d.ts

@@ -0,0 +1,61 @@
+import { EnableBy, Env, IPluginConfig } from '../types';
+declare type PluginType = 'plugin' | 'preset';
+interface IOpts {
+    path: string;
+    cwd: string;
+    type: PluginType;
+}
+export interface IPluginObject {
+    id: string;
+    key: string;
+    apply?: Function;
+    config?: IPluginConfig;
+    enableBy?: EnableBy | (() => boolean);
+}
+export declare class Plugin {
+    private cwd;
+    type: PluginType;
+    path: string;
+    id: string;
+    key: string;
+    apply: Function;
+    config: IPluginConfig;
+    time: {
+        register?: number;
+        hooks: Record<string, number[]>;
+    };
+    enableBy: EnableBy | ((opts: {
+        userConfig: any;
+        config: any;
+        env: Env;
+    }) => boolean);
+    constructor(opts: IOpts);
+    merge(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: any;
+    }): void;
+    getId(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+        pkgJSONPath: string | null;
+    }): any;
+    getKey(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+    }): string;
+    static isPluginOrPreset(type: 'plugin' | 'preset', name: string): boolean;
+    static stripNoneUmiScope(name: string): string;
+    static getPluginsAndPresets(opts: {
+        cwd: string;
+        pkg: any;
+        userConfig: any;
+        plugins?: string[];
+        presets?: string[];
+        prefix: string;
+    }): {
+        presets: Plugin[];
+        plugins: Plugin[];
+    };
+}
+export {};

package/dist/service/plugin.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/service/plugin.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  Plugin: () => Plugin
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_esbuild = __toESM(require("@4399ywkf/bundler-utils/compiled/esbuild"));
+var import_utils = require("@4399ywkf/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_types = require("../types");
+var RE = {
+  plugin: /^(@umijs\/|umi-)plugin-/,
+  preset: /^(@umijs\/|umi-)preset-/
+};
+var Plugin = class _Plugin {
+  cwd;
+  type;
+  path;
+  id;
+  key;
+  apply;
+  config = {};
+  time = { hooks: {} };
+  enableBy = import_types.EnableBy.register;
+  constructor(opts) {
+    this.type = opts.type;
+    this.path = (0, import_utils.winPath)(opts.path);
+    this.cwd = opts.cwd;
+    (0, import_assert.default)(
+      (0, import_fs.existsSync)(this.path),
+      `Invalid ${this.type} ${this.path}, it's not exists.`
+    );
+    let pkg = null;
+    let isPkgEntry = false;
+    const pkgJSONPath = import_utils.pkgUp.pkgUpSync({ cwd: this.path });
+    if (pkgJSONPath) {
+      pkg = require(pkgJSONPath);
+      isPkgEntry = (0, import_utils.winPath)((0, import_path.join)((0, import_path.dirname)(pkgJSONPath), pkg.main || "index.js")) === (0, import_utils.winPath)(this.path);
+    }
+    this.id = this.getId({ pkg, isPkgEntry, pkgJSONPath });
+    this.key = this.getKey({ pkg, isPkgEntry });
+    this.apply = () => {
+      import_utils.register.register({
+        implementor: import_esbuild.default,
+        exts: [".ts", ".mjs"]
+      });
+      import_utils.register.clearFiles();
+      let ret;
+      try {
+        ret = require(this.path);
+      } catch (e) {
+        throw new Error(
+          `Register ${this.type} ${this.path} failed, since ${e.message}`,
+          { cause: e }
+        );
+      } finally {
+        import_utils.register.restore();
+      }
+      return ret.__esModule ? ret.default : ret;
+    };
+  }
+  merge(opts) {
+    if (opts.key) this.key = opts.key;
+    if (opts.config) this.config = opts.config;
+    if (opts.enableBy) this.enableBy = opts.enableBy;
+  }
+  getId(opts) {
+    let id;
+    if (opts.isPkgEntry) {
+      id = opts.pkg.name;
+    } else if ((0, import_utils.winPath)(this.path).startsWith((0, import_utils.winPath)(this.cwd))) {
+      id = `./${(0, import_utils.winPath)((0, import_path.relative)(this.cwd, this.path))}`;
+    } else if (opts.pkgJSONPath) {
+      id = (0, import_utils.winPath)(
+        (0, import_path.join)(opts.pkg.name, (0, import_path.relative)((0, import_path.dirname)(opts.pkgJSONPath), this.path))
+      );
+    } else {
+      id = (0, import_utils.winPath)(this.path);
+    }
+    id = id.replace("@4399ywkf/preset-umi/lib/plugins", "@@");
+    id = id.replace(/\.js$/, "");
+    return id;
+  }
+  getKey(opts) {
+    function nameToKey(name) {
+      return name.split(".").map((part) => import_utils.lodash.camelCase(part)).join(".");
+    }
+    return nameToKey(
+      opts.isPkgEntry ? _Plugin.stripNoneUmiScope(opts.pkg.name).replace(RE[this.type], "") : (0, import_path.basename)(this.path, (0, import_path.extname)(this.path))
+    );
+  }
+  static isPluginOrPreset(type, name) {
+    return RE[type].test(_Plugin.stripNoneUmiScope(name));
+  }
+  static stripNoneUmiScope(name) {
+    if (name.charAt(0) === "@" && !name.startsWith("@4399ywkf/")) {
+      name = name.split("/")[1];
+    }
+    return name;
+  }
+  static getPluginsAndPresets(opts) {
+    function get(type) {
+      const types = `${type}s`;
+      return [
+        // opts
+        ...opts[types] || [],
+        // env
+        ...(process.env[`${opts.prefix}_${types}`.toUpperCase()] || "").split(",").filter(Boolean),
+        // dependencies
+        // ...Object.keys(opts.pkg.devDependencies || {})
+        //   .concat(Object.keys(opts.pkg.dependencies || {}))
+        //   .filter(Plugin.isPluginOrPreset.bind(null, type)),
+        // user config
+        ...opts.userConfig[types] || []
+      ].map((path) => {
+        (0, import_assert.default)(
+          typeof path === "string",
+          `Invalid plugin ${path}, it must be string.`
+        );
+        let resolved;
+        try {
+          resolved = import_utils.resolve.sync(path, {
+            basedir: opts.cwd,
+            extensions: [".tsx", ".ts", ".mjs", ".jsx", ".js"]
+          });
+        } catch (_e) {
+          throw new Error(`Invalid plugin ${path}, can not be resolved.`, {
+            cause: _e
+          });
+        }
+        return new _Plugin({
+          path: resolved,
+          type,
+          cwd: opts.cwd
+        });
+      });
+    }
+    return {
+      presets: get("preset"),
+      plugins: get("plugin")
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Plugin
+});