@4399ywkf/core 4.0.61

package/dist/service/service.js

@@ -0,0 +1,538 @@
+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/service.ts
+var service_exports = {};
+__export(service_exports, {
+  Service: () => Service
+});
+module.exports = __toCommonJS(service_exports);
+var import_tapable = require("@4399ywkf/bundler-utils/compiled/tapable");
+var import_utils = require("@4399ywkf/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_config = require("../config/config");
+var import_constants = require("../constants");
+var import_types = require("../types");
+var import_env = require("./env");
+var import_path2 = require("./path");
+var import_plugin = require("./plugin");
+var import_pluginAPI = require("./pluginAPI");
+var import_telemetry = require("./telemetry");
+var Service = class {
+  opts;
+  appData = {};
+  args = { _: [], $0: "" };
+  commands = {};
+  generators = {};
+  config = {};
+  configSchemas = {};
+  configDefaults = {};
+  configOnChanges = {};
+  cwd;
+  env;
+  hooks = {};
+  name = "";
+  paths = {};
+  // preset is plugin with different type
+  plugins = {};
+  keyToPluginMap = {};
+  pluginMethods = {};
+  skipPluginIds = /* @__PURE__ */ new Set();
+  stage = import_types.ServiceStage.uninitialized;
+  userConfig = {};
+  configManager = null;
+  pkg = {};
+  pkgPath = "";
+  telemetry = new import_telemetry.Telemetry();
+  constructor(opts) {
+    this.cwd = opts.cwd;
+    this.env = opts.env;
+    this.opts = opts;
+    (0, import_assert.default)((0, import_fs.existsSync)(this.cwd), `Invalid cwd ${this.cwd}, it's not found.`);
+  }
+  applyPlugins(opts) {
+    const hooks = this.hooks[opts.key] || [];
+    let type = opts.type;
+    if (!type) {
+      if (opts.key.startsWith("on")) {
+        type = import_types.ApplyPluginsType.event;
+      } else if (opts.key.startsWith("modify")) {
+        type = import_types.ApplyPluginsType.modify;
+      } else if (opts.key.startsWith("add")) {
+        type = import_types.ApplyPluginsType.add;
+      } else {
+        throw new Error(
+          `Invalid applyPlugins arguments, type must be supplied for key ${opts.key}.`
+        );
+      }
+    }
+    switch (type) {
+      case import_types.ApplyPluginsType.add:
+        (0, import_assert.default)(
+          !("initialValue" in opts) || Array.isArray(opts.initialValue),
+          `applyPlugins failed, opts.initialValue must be Array if opts.type is add.`
+        );
+        const tAdd = new import_tapable.AsyncSeriesWaterfallHook(["memo"]);
+        for (const hook of hooks) {
+          if (!this.isPluginEnable(hook)) continue;
+          tAdd.tapPromise(
+            {
+              name: hook.plugin.key,
+              stage: hook.stage || 0,
+              before: hook.before
+            },
+            async (memo) => {
+              var _a, _b;
+              const dateStart = /* @__PURE__ */ new Date();
+              const items = await hook.fn(opts.args);
+              (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
+              hook.plugin.time.hooks[opts.key].push(
+                (/* @__PURE__ */ new Date()).getTime() - dateStart.getTime()
+              );
+              return memo.concat(items);
+            }
+          );
+        }
+        return tAdd.promise(opts.initialValue || []);
+      case import_types.ApplyPluginsType.modify:
+        const tModify = new import_tapable.AsyncSeriesWaterfallHook(["memo"]);
+        for (const hook of hooks) {
+          if (!this.isPluginEnable(hook)) continue;
+          tModify.tapPromise(
+            {
+              name: hook.plugin.key,
+              stage: hook.stage || 0,
+              before: hook.before
+            },
+            async (memo) => {
+              var _a, _b;
+              const dateStart = /* @__PURE__ */ new Date();
+              const ret = await hook.fn(memo, opts.args);
+              (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
+              hook.plugin.time.hooks[opts.key].push(
+                (/* @__PURE__ */ new Date()).getTime() - dateStart.getTime()
+              );
+              return ret;
+            }
+          );
+        }
+        return tModify.promise(opts.initialValue);
+      case import_types.ApplyPluginsType.event:
+        if (opts.sync) {
+          const tEvent2 = new import_tapable.SyncWaterfallHook(["_"]);
+          hooks.forEach((hook) => {
+            if (this.isPluginEnable(hook)) {
+              tEvent2.tap(
+                {
+                  name: hook.plugin.key,
+                  stage: hook.stage || 0,
+                  before: hook.before
+                },
+                () => {
+                  var _a, _b;
+                  const dateStart = /* @__PURE__ */ new Date();
+                  hook.fn(opts.args);
+                  (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
+                  hook.plugin.time.hooks[opts.key].push(
+                    (/* @__PURE__ */ new Date()).getTime() - dateStart.getTime()
+                  );
+                }
+              );
+            }
+          });
+          return tEvent2.call(1);
+        }
+        const tEvent = new import_tapable.AsyncSeriesWaterfallHook(["_"]);
+        for (const hook of hooks) {
+          if (!this.isPluginEnable(hook)) continue;
+          tEvent.tapPromise(
+            {
+              name: hook.plugin.key,
+              stage: hook.stage || 0,
+              before: hook.before
+            },
+            async () => {
+              var _a, _b;
+              const dateStart = /* @__PURE__ */ new Date();
+              await hook.fn(opts.args);
+              (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
+              hook.plugin.time.hooks[opts.key].push(
+                (/* @__PURE__ */ new Date()).getTime() - dateStart.getTime()
+              );
+            }
+          );
+        }
+        return tEvent.promise(1);
+      default:
+        throw new Error(
+          `applyPlugins failed, type is not defined or is not matched, got ${opts.type}.`
+        );
+    }
+  }
+  async run(opts) {
+    const { name, args = {} } = opts;
+    args._ = args._ || [];
+    if (args._[0] === name) args._.shift();
+    this.args = args;
+    this.name = name;
+    this.stage = import_types.ServiceStage.init;
+    (0, import_env.loadEnv)({ cwd: this.cwd, envFile: ".env" });
+    let pkg = {};
+    let pkgPath = "";
+    try {
+      pkg = require((0, import_path.join)(this.cwd, "package.json"));
+      pkgPath = (0, import_path.join)(this.cwd, "package.json");
+    } catch (_e) {
+      if (this.cwd !== process.cwd()) {
+        try {
+          pkg = require((0, import_path.join)(process.cwd(), "package.json"));
+          pkgPath = (0, import_path.join)(process.cwd(), "package.json");
+        } catch (_e2) {
+        }
+      }
+    }
+    this.pkg = pkg;
+    this.pkgPath = pkgPath || (0, import_path.join)(this.cwd, "package.json");
+    const prefix = this.opts.frameworkName || import_constants.DEFAULT_FRAMEWORK_NAME;
+    const specifiedEnv = process.env[`${prefix}_ENV`.toUpperCase()];
+    const configManager = new import_config.Config({
+      cwd: this.cwd,
+      env: this.env,
+      defaultConfigFiles: this.opts.defaultConfigFiles,
+      specifiedEnv
+    });
+    this.configManager = configManager;
+    this.userConfig = configManager.getUserConfig().config;
+    this.paths = await this.getPaths();
+    const { plugins, presets } = import_plugin.Plugin.getPluginsAndPresets({
+      cwd: this.cwd,
+      pkg,
+      plugins: [require.resolve("./generatePlugin")].concat(
+        this.opts.plugins || []
+      ),
+      presets: [require.resolve("./servicePlugin")].concat(
+        this.opts.presets || []
+      ),
+      userConfig: this.userConfig,
+      prefix
+    });
+    this.stage = import_types.ServiceStage.initPresets;
+    const presetPlugins = [];
+    while (presets.length) {
+      await this.initPreset({
+        preset: presets.shift(),
+        presets,
+        plugins: presetPlugins
+      });
+    }
+    plugins.unshift(...presetPlugins);
+    this.stage = import_types.ServiceStage.initPlugins;
+    while (plugins.length) {
+      await this.initPlugin({ plugin: plugins.shift(), plugins });
+    }
+    const command = this.commands[name];
+    if (!command) {
+      this.commandGuessHelper(Object.keys(this.commands), name);
+      throw Error(`Invalid command ${import_utils.chalk.red(name)}, it's not registered.`);
+    }
+    for (const id of Object.keys(this.plugins)) {
+      const { config, key } = this.plugins[id];
+      if (config.schema) this.configSchemas[key] = config.schema;
+      if (config.default !== void 0) {
+        this.configDefaults[key] = config.default;
+      }
+      this.configOnChanges[key] = config.onChange || import_types.ConfigChangeType.reload;
+    }
+    this.stage = import_types.ServiceStage.resolveConfig;
+    const { defaultConfig } = await this.resolveConfig();
+    if (this.config.outputPath) {
+      this.paths.absOutputPath = (0, import_path.isAbsolute)(this.config.outputPath) ? this.config.outputPath : (0, import_path.join)(this.cwd, this.config.outputPath);
+    }
+    this.paths = await this.applyPlugins({
+      key: "modifyPaths",
+      initialValue: this.paths
+    });
+    const storage = await this.applyPlugins({
+      key: "modifyTelemetryStorage",
+      initialValue: import_telemetry.noopStorage
+    });
+    this.telemetry.useStorage(storage);
+    this.stage = import_types.ServiceStage.collectAppData;
+    this.appData = await this.applyPlugins({
+      key: "modifyAppData",
+      initialValue: {
+        // base
+        cwd: this.cwd,
+        pkg,
+        pkgPath,
+        plugins: this.plugins,
+        presets,
+        name,
+        args,
+        // config
+        userConfig: this.userConfig,
+        mainConfigFile: configManager.mainConfigFile,
+        config: this.config,
+        defaultConfig
+        // TODO
+        // moduleGraph,
+        // routes,
+        // npmClient,
+        // nodeVersion,
+        // gitInfo,
+        // gitBranch,
+        // debugger info,
+        // devPort,
+        // devHost,
+        // env
+      }
+    });
+    this.stage = import_types.ServiceStage.onCheck;
+    await this.applyPlugins({
+      key: "onCheck"
+    });
+    this.stage = import_types.ServiceStage.onStart;
+    await this.applyPlugins({
+      key: "onStart"
+    });
+    this.stage = import_types.ServiceStage.runCommand;
+    let ret = await command.fn({ args });
+    this._profilePlugins();
+    return ret;
+  }
+  async getPaths() {
+    const paths = (0, import_path2.getPaths)({
+      cwd: this.cwd,
+      env: this.env,
+      prefix: this.opts.frameworkName || import_constants.DEFAULT_FRAMEWORK_NAME
+    });
+    return paths;
+  }
+  async resolveConfig() {
+    (0, import_assert.default)(
+      this.stage > import_types.ServiceStage.init,
+      `Can't generate final config before init stage`
+    );
+    const resolveMode = this.commands[this.name].configResolveMode;
+    const config = await this.applyPlugins({
+      key: "modifyConfig",
+      // why clone deep?
+      // user may change the config in modifyConfig
+      // e.g. memo.alias = xxx
+      initialValue: import_utils.lodash.cloneDeep(
+        resolveMode === "strict" ? this.configManager.getConfig({
+          schemas: this.configSchemas
+        }).config : this.configManager.getUserConfig().config
+      ),
+      args: { paths: this.paths }
+    });
+    const defaultConfig = await this.applyPlugins({
+      key: "modifyDefaultConfig",
+      // 避免 modifyDefaultConfig 时修改 this.configDefaults
+      initialValue: import_utils.lodash.cloneDeep(this.configDefaults)
+    });
+    this.config = import_utils.lodash.merge(defaultConfig, config);
+    return { config, defaultConfig };
+  }
+  _profilePlugins() {
+    if (this.args.profilePlugins) {
+      console.log();
+      Object.keys(this.plugins).map((id) => {
+        const plugin = this.plugins[id];
+        const total = totalTime(plugin);
+        return {
+          id,
+          total,
+          register: plugin.time.register || 0,
+          hooks: plugin.time.hooks
+        };
+      }).filter((time) => {
+        return time.total > (this.args.profilePluginsLimit ?? 10);
+      }).sort((a, b) => b.total > a.total ? 1 : -1).forEach((time) => {
+        console.log(import_utils.chalk.green("plugin"), time.id, time.total);
+        if (this.args.profilePluginsVerbose) {
+          console.log("      ", import_utils.chalk.green("register"), time.register);
+          console.log(
+            "      ",
+            import_utils.chalk.green("hooks"),
+            JSON.stringify(sortHooks(time.hooks))
+          );
+        }
+      });
+    }
+    function sortHooks(hooks) {
+      const ret = {};
+      Object.keys(hooks).sort((a, b) => {
+        return add(hooks[b]) - add(hooks[a]);
+      }).forEach((key) => {
+        ret[key] = hooks[key];
+      });
+      return ret;
+    }
+    function totalTime(plugin) {
+      const time = plugin.time;
+      return (time.register || 0) + Object.values(time.hooks).reduce((a, b) => a + add(b), 0);
+    }
+    function add(nums) {
+      return nums.reduce((a, b) => a + b, 0);
+    }
+  }
+  async initPreset(opts) {
+    const { presets, plugins } = await this.initPlugin({
+      plugin: opts.preset,
+      presets: opts.presets,
+      plugins: opts.plugins
+    });
+    opts.presets.unshift(...presets || []);
+    opts.plugins.push(...plugins || []);
+  }
+  async initPlugin(opts) {
+    var _a, _b;
+    (0, import_assert.default)(
+      !this.plugins[opts.plugin.id],
+      `${opts.plugin.type} ${opts.plugin.id} is already registered by ${(_a = this.plugins[opts.plugin.id]) == null ? void 0 : _a.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`
+    );
+    this.plugins[opts.plugin.id] = opts.plugin;
+    const pluginAPI = new import_pluginAPI.PluginAPI({
+      plugin: opts.plugin,
+      service: this
+    });
+    pluginAPI.registerPresets = pluginAPI.registerPresets.bind(
+      pluginAPI,
+      opts.presets || []
+    );
+    pluginAPI.registerPlugins = pluginAPI.registerPlugins.bind(
+      pluginAPI,
+      opts.plugins
+    );
+    const proxyPluginAPI = import_pluginAPI.PluginAPI.proxyPluginAPI({
+      service: this,
+      pluginAPI,
+      serviceProps: [
+        "appData",
+        "applyPlugins",
+        "args",
+        "config",
+        "cwd",
+        "pkg",
+        "pkgPath",
+        "name",
+        "paths",
+        "userConfig",
+        "env",
+        "isPluginEnable"
+      ],
+      staticProps: {
+        ApplyPluginsType: import_types.ApplyPluginsType,
+        ConfigChangeType: import_types.ConfigChangeType,
+        EnableBy: import_types.EnableBy,
+        ServiceStage: import_types.ServiceStage,
+        service: this
+      }
+    });
+    let dateStart = /* @__PURE__ */ new Date();
+    let ret = await opts.plugin.apply()(proxyPluginAPI);
+    opts.plugin.time.register = (/* @__PURE__ */ new Date()).getTime() - dateStart.getTime();
+    if (opts.plugin.type === "plugin") {
+      (0, import_assert.default)(!ret, `plugin should return nothing`);
+    }
+    (0, import_assert.default)(
+      !this.keyToPluginMap[opts.plugin.key],
+      `key ${opts.plugin.key} is already registered by ${(_b = this.keyToPluginMap[opts.plugin.key]) == null ? void 0 : _b.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`
+    );
+    this.keyToPluginMap[opts.plugin.key] = opts.plugin;
+    if (ret == null ? void 0 : ret.presets) {
+      ret.presets = ret.presets.map(
+        (preset) => new import_plugin.Plugin({
+          path: preset,
+          type: import_types.PluginType.preset,
+          cwd: this.cwd
+        })
+      );
+    }
+    if (ret == null ? void 0 : ret.plugins) {
+      ret.plugins = ret.plugins.map(
+        (plugin) => new import_plugin.Plugin({
+          path: plugin,
+          type: import_types.PluginType.plugin,
+          cwd: this.cwd
+        })
+      );
+    }
+    return ret || {};
+  }
+  isPluginEnable(hook) {
+    let plugin;
+    if (hook.plugin) {
+      plugin = hook.plugin;
+    } else {
+      plugin = this.keyToPluginMap[hook];
+      if (!plugin) return false;
+    }
+    const { id, key, enableBy } = plugin;
+    if (this.skipPluginIds.has(id)) return false;
+    if (this.userConfig[key] === false) return false;
+    if (this.config[key] === false) return false;
+    if (enableBy === import_types.EnableBy.config) {
+      return key in this.userConfig || this.config && key in this.config;
+    }
+    if (typeof enableBy === "function")
+      return enableBy({
+        userConfig: this.userConfig,
+        config: this.config,
+        env: this.env
+      });
+    return true;
+  }
+  commandGuessHelper(commands, currentCmd) {
+    const altCmds = commands.filter((cmd) => {
+      return import_utils.fastestLevenshtein.distance(currentCmd, cmd) < currentCmd.length * 0.6 && currentCmd !== cmd;
+    });
+    const printHelper = altCmds.slice(0, 3).map((cmd) => {
+      return ` - ${import_utils.chalk.green(cmd)}`;
+    }).join("\n");
+    if (altCmds.length) {
+      console.log();
+      console.log(
+        [
+          import_utils.chalk.cyan(
+            altCmds.length === 1 ? "Did you mean this command ?" : "Did you mean one of these commands ?"
+          ),
+          printHelper
+        ].join("\n")
+      );
+      console.log();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Service
+});

package/dist/service/servicePlugin.d.ts

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

package/dist/service/servicePlugin.js

@@ -0,0 +1,37 @@
+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/servicePlugin.ts
+var servicePlugin_exports = {};
+__export(servicePlugin_exports, {
+  default: () => servicePlugin_default
+});
+module.exports = __toCommonJS(servicePlugin_exports);
+var servicePlugin_default = (api) => {
+  [
+    "onCheck",
+    "onStart",
+    "modifyAppData",
+    "modifyConfig",
+    "modifyDefaultConfig",
+    "modifyPaths",
+    "modifyTelemetryStorage"
+  ].forEach((name) => {
+    api.registerMethod({ name });
+  });
+};

package/dist/service/telemetry.d.ts

@@ -0,0 +1,32 @@
+declare type MetreEvent = {
+    name: string;
+    timestamp?: number;
+    payload: any;
+};
+interface IStorage {
+    save(e: MetreEvent): Promise<void>;
+}
+export interface IMetry {
+    record(e: MetreEvent): void;
+    recordAsync(e: MetreEvent): Promise<boolean>;
+    flush(): Promise<void>;
+}
+export declare class Telemetry implements IMetry {
+    private queuedEvents;
+    private storage;
+    constructor();
+    prefixWith(prefix: string): IMetry;
+    useStorage(s: IStorage): void;
+    record(e: MetreEvent): void;
+    recordAsync(e: MetreEvent): Promise<boolean>;
+    flush(): Promise<void>;
+    private scheduleFlush;
+    private afterFlush;
+    private unFinishedEvents;
+    private addTimeStamp;
+}
+declare class NoopStorage implements IStorage {
+    save(_e: MetreEvent): Promise<void>;
+}
+export declare const noopStorage: NoopStorage;
+export {};