@umijs/core 4.0.56 → 4.0.57

package/dist/config/config.js

@@ -183,11 +183,20 @@ var Config = class {
       configKeys.delete(key);
       if (!opts.config[key])
         continue;
-      const schema = opts.schemas[key](import_joi.default);
-      (0, import_assert.default)(import_joi.default.isSchema(schema), `schema for config ${key} is not valid.`);
-      const { error } = schema.validate(opts.config[key]);
-      if (error)
-        errors.set(key, error);
+      const schema = opts.schemas[key]({ ...import_joi.default, zod: import_utils.zod });
+      if (import_joi.default.isSchema(schema)) {
+        const { error } = schema.validate(opts.config[key]);
+        if (error)
+          errors.set(key, error);
+      } else {
+        (0, import_assert.default)(
+          (0, import_utils.isZodSchema)(schema),
+          `schema for config ${key} is not valid, neither joi nor zod.`
+        );
+        const { error } = schema.safeParse(opts.config[key]);
+        if (error)
+          errors.set(key, error);
+      }
     }
     (0, import_assert.default)(
       errors.size === 0,

package/dist/route/routesConvention.js

@@ -77,7 +77,7 @@ function visitFiles(opts) {
 }
 function createRoutePath(routeId) {
   let path = routeId.replace(/^\$$/, "*").replace(/(\/|\.)\$$/, "/*").replace(/\$/g, ":").replace(/\./g, "/");
-  path = /\b\/?index\/index$/.test(path) ? path.replace(/\/?index$/, "") : path;
+  path = /(^|\/)index\/index$/.test(path) ? path.replace(/\/index$/, "") : path;
   path = /\b\/?(?<!:)index$/.test(path) ? path.replace(/\/?index$/, "") : path;
   path = /\b\/?README$/.test(path) ? path.replace(/\/?README$/, "") : path;
   return path;

package/dist/service/pluginAPI.d.ts

@@ -5,14 +5,16 @@ import { Generator } from './generator';
 import { IOpts as IHookOpts } from './hook';
 import { Plugin } from './plugin';
 import { Service } from './service';
+import type { IMetry } from './telemetry';
 declare type Logger = typeof logger;
 declare const resolveConfigModes: readonly ["strict", "loose"];
-export declare type ResolveConfigMode = typeof resolveConfigModes[number];
+export declare type ResolveConfigMode = (typeof resolveConfigModes)[number];
 declare type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 export declare class PluginAPI {
     service: Service;
     plugin: Plugin;
     logger: Logger;
+    telemetry: IMetry;
     constructor(opts: {
         service: Service;
         plugin: Plugin;

package/dist/service/pluginAPI.js

@@ -45,6 +45,7 @@ var PluginAPI = class {
   constructor(opts) {
     this.service = opts.service;
     this.plugin = opts.plugin;
+    this.telemetry = opts.service.telemetry.prefixWith(this.plugin.key);
     const loggerKeys = [
       "wait",
       "error",

package/dist/service/service.d.ts

@@ -6,6 +6,7 @@ import { Command } from './command';
 import { Generator } from './generator';
 import { Hook } from './hook';
 import { Plugin } from './plugin';
+import { Telemetry } from './telemetry';
 interface IOpts {
     cwd: string;
     env: Env;
@@ -67,6 +68,7 @@ export declare class Service {
         [key: string]: any;
     };
     pkgPath: string;
+    telemetry: Telemetry;
     constructor(opts: IOpts);
     applyPlugins<T>(opts: {
         key: string;
@@ -134,6 +136,7 @@ export interface IServicePluginAPI {
     }>;
     modifyDefaultConfig: IModify<typeof Service.prototype.config, null>;
     modifyPaths: IModify<typeof Service.prototype.paths, null>;
+    modifyTelemetryStorage: IModify<typeof Service.prototype.telemetry, null>;
     ApplyPluginsType: typeof ApplyPluginsType;
     ConfigChangeType: typeof ConfigChangeType;
     EnableBy: typeof EnableBy;

package/dist/service/service.js

@@ -44,6 +44,7 @@ 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 {
   constructor(opts) {
     this.appData = {};
@@ -67,6 +68,7 @@ var Service = class {
     this.configManager = null;
     this.pkg = {};
     this.pkgPath = "";
+    this.telemetry = new import_telemetry.Telemetry();
     this.cwd = opts.cwd;
     this.env = opts.env;
     this.opts = opts;
@@ -279,6 +281,11 @@ var Service = class {
       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",

package/dist/service/servicePlugin.js

@@ -29,7 +29,8 @@ var servicePlugin_default = (api) => {
     "modifyAppData",
     "modifyConfig",
     "modifyDefaultConfig",
-    "modifyPaths"
+    "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 {};

package/dist/service/telemetry.js

@@ -0,0 +1,127 @@
+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/telemetry.ts
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  Telemetry: () => Telemetry,
+  noopStorage: () => noopStorage
+});
+module.exports = __toCommonJS(telemetry_exports);
+var Telemetry = class {
+  constructor() {
+    this.queuedEvents = [];
+    this.storage = new NoopStorage();
+    this.afterFlush = () => {
+      const un = this.unFinishedEvents();
+      if (un.length) {
+        this.scheduleFlush();
+      } else {
+        this.queuedEvents = [];
+      }
+    };
+  }
+  prefixWith(prefix) {
+    const upStream = this;
+    return {
+      record(e) {
+        const { name, ...rest } = e;
+        upStream.record({
+          name: `${prefix}:${name}`,
+          ...rest
+        });
+      },
+      async flush() {
+        return upStream.flush();
+      },
+      recordAsync(e) {
+        const { name, ...rest } = e;
+        return upStream.recordAsync({
+          name: `${prefix}:${name}`,
+          ...rest
+        });
+      }
+    };
+  }
+  useStorage(s) {
+    this.storage = s;
+  }
+  record(e) {
+    this.storage.save(this.addTimeStamp(e)).catch(() => {
+      this.queuedEvents.push({ event: e, tried: 1, status: "queued" });
+      this.scheduleFlush();
+    });
+  }
+  async recordAsync(e) {
+    try {
+      await this.storage.save(this.addTimeStamp(e));
+      return true;
+    } catch (e2) {
+      return false;
+    }
+  }
+  async flush() {
+    const events = this.unFinishedEvents().map((e) => {
+      if (e.status === "queued") {
+        e.status = "sending";
+        e.tried++;
+        e.promise = this.storage.save(e.event).then(
+          () => {
+            e.status = "sent";
+          },
+          () => {
+            e.status = "queued";
+          }
+        );
+      }
+      return e;
+    });
+    this.queuedEvents = events;
+    await Promise.all(events.map(({ promise }) => promise));
+  }
+  scheduleFlush() {
+    setTimeout(() => {
+      this.flush().then(this.afterFlush, this.afterFlush);
+    }, 5e3);
+  }
+  unFinishedEvents() {
+    return this.queuedEvents.filter((e) => {
+      if (e.status === "sent") {
+        return false;
+      }
+      return e.tried < 3;
+    });
+  }
+  addTimeStamp(e) {
+    if (!e.timestamp) {
+      e.timestamp = Date.now();
+    }
+    return e;
+  }
+};
+var NoopStorage = class {
+  async save(_e) {
+    return;
+  }
+};
+var noopStorage = new NoopStorage();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Telemetry,
+  noopStorage
+});

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import joi from '@umijs/utils/compiled/@hapi/joi';
+import zod, { z } from '@umijs/utils/compiled/zod';
 export declare enum Env {
     development = "development",
     production = "production",
@@ -11,7 +12,9 @@ export declare enum PluginType {
 export interface IPluginConfig {
     default?: any;
     schema?: {
-        (joi: joi.Root): joi.Schema;
+        (joi: joi.Root & {
+            zod: typeof z;
+        }): joi.Schema | zod.Schema;
     };
     onChange?: string | Function;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/core",
-  "version": "4.0.56",
+  "version": "4.0.57",
   "homepage": "https://github.com/umijs/umi/tree/master/packages/core#readme",
   "bugs": "https://github.com/umijs/umi/issues",
   "repository": {
@@ -21,8 +21,8 @@
     "test": "umi-scripts jest-turbo"
   },
   "dependencies": {
-    "@umijs/bundler-utils": "4.0.56",
-    "@umijs/utils": "4.0.56"
+    "@umijs/bundler-utils": "4.0.57",
+    "@umijs/utils": "4.0.57"
   },
   "devDependencies": {
     "dotenv": "16.0.0",