@4399ywkf/core 4.0.61

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 {
+  queuedEvents = [];
+  storage = new NoopStorage();
+  constructor() {
+  }
+  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);
+  }
+  afterFlush = () => {
+    const un = this.unFinishedEvents();
+    if (un.length) {
+      this.scheduleFlush();
+    } else {
+      this.queuedEvents = [];
+    }
+  };
+  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/service/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isPromise(obj: any): boolean;
+export declare function makeArray(item: any): any[];

package/dist/service/utils.js

@@ -0,0 +1,36 @@
+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/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  isPromise: () => isPromise,
+  makeArray: () => makeArray
+});
+module.exports = __toCommonJS(utils_exports);
+function isPromise(obj) {
+  return (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+function makeArray(item) {
+  return Array.isArray(item) ? item : [item];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPromise,
+  makeArray
+});

package/dist/types.d.ts

@@ -0,0 +1,116 @@
+import joi from '@4399ywkf/utils/compiled/@hapi/joi';
+import zod, { z } from '@4399ywkf/utils/compiled/zod';
+export declare enum Env {
+    development = "development",
+    production = "production",
+    test = "test"
+}
+export declare enum PluginType {
+    preset = "preset",
+    plugin = "plugin"
+}
+export interface IPluginConfig {
+    default?: any;
+    schema?: {
+        (joi: joi.Root & {
+            zod: typeof z;
+        }): joi.Schema | zod.Schema;
+    };
+    onChange?: string | Function;
+}
+export declare enum ServiceStage {
+    uninitialized = 0,
+    init = 1,
+    initPresets = 2,
+    initPlugins = 3,
+    resolveConfig = 4,
+    collectAppData = 5,
+    onCheck = 6,
+    onStart = 7,
+    runCommand = 8
+}
+export declare enum ConfigChangeType {
+    reload = "reload",
+    regenerateTmpFiles = "regenerateTmpFiles"
+}
+export declare type ChangeTypeValue = string | `${ConfigChangeType}` | Function;
+export declare type IOnChangeTypes = Record<string, ChangeTypeValue>;
+export declare enum ApplyPluginsType {
+    add = "add",
+    modify = "modify",
+    event = "event"
+}
+export declare enum EnableBy {
+    register = "register",
+    config = "config"
+}
+export interface IRoute {
+    path: string;
+    absPath: string;
+    file: string;
+    id: string;
+    parentId?: string;
+    [key: string]: any;
+}
+export interface IEvent<T> {
+    (fn: {
+        (args: T): void;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): void;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+}
+export interface IModify<T, U> {
+    (fn: {
+        (initialValue: T, args: U): T;
+    }): void;
+    (fn: {
+        (initialValue: T, args: U): Promise<T>;
+    }): void;
+    (args: {
+        fn: {
+            (initialValue: T, args: U): T;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+    (args: {
+        fn: {
+            (initialValue: T, args: U): Promise<T>;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+}
+export interface IAdd<T, U> {
+    (fn: {
+        (args: T): U | U[];
+    }): void;
+    (fn: {
+        (args: T): Promise<U | U[]>;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): U | U[];
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): Promise<U | U[]>;
+            name?: string;
+            before?: string | string[];
+            stage?: number;
+        };
+    }): void;
+}
+export declare type IFrameworkType = 'vue' | 'react';

package/dist/types.js

@@ -0,0 +1,77 @@
+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/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ApplyPluginsType: () => ApplyPluginsType,
+  ConfigChangeType: () => ConfigChangeType,
+  EnableBy: () => EnableBy,
+  Env: () => Env,
+  PluginType: () => PluginType,
+  ServiceStage: () => ServiceStage
+});
+module.exports = __toCommonJS(types_exports);
+var Env = /* @__PURE__ */ ((Env2) => {
+  Env2["development"] = "development";
+  Env2["production"] = "production";
+  Env2["test"] = "test";
+  return Env2;
+})(Env || {});
+var PluginType = /* @__PURE__ */ ((PluginType2) => {
+  PluginType2["preset"] = "preset";
+  PluginType2["plugin"] = "plugin";
+  return PluginType2;
+})(PluginType || {});
+var ServiceStage = /* @__PURE__ */ ((ServiceStage2) => {
+  ServiceStage2[ServiceStage2["uninitialized"] = 0] = "uninitialized";
+  ServiceStage2[ServiceStage2["init"] = 1] = "init";
+  ServiceStage2[ServiceStage2["initPresets"] = 2] = "initPresets";
+  ServiceStage2[ServiceStage2["initPlugins"] = 3] = "initPlugins";
+  ServiceStage2[ServiceStage2["resolveConfig"] = 4] = "resolveConfig";
+  ServiceStage2[ServiceStage2["collectAppData"] = 5] = "collectAppData";
+  ServiceStage2[ServiceStage2["onCheck"] = 6] = "onCheck";
+  ServiceStage2[ServiceStage2["onStart"] = 7] = "onStart";
+  ServiceStage2[ServiceStage2["runCommand"] = 8] = "runCommand";
+  return ServiceStage2;
+})(ServiceStage || {});
+var ConfigChangeType = /* @__PURE__ */ ((ConfigChangeType2) => {
+  ConfigChangeType2["reload"] = "reload";
+  ConfigChangeType2["regenerateTmpFiles"] = "regenerateTmpFiles";
+  return ConfigChangeType2;
+})(ConfigChangeType || {});
+var ApplyPluginsType = /* @__PURE__ */ ((ApplyPluginsType2) => {
+  ApplyPluginsType2["add"] = "add";
+  ApplyPluginsType2["modify"] = "modify";
+  ApplyPluginsType2["event"] = "event";
+  return ApplyPluginsType2;
+})(ApplyPluginsType || {});
+var EnableBy = /* @__PURE__ */ ((EnableBy2) => {
+  EnableBy2["register"] = "register";
+  EnableBy2["config"] = "config";
+  return EnableBy2;
+})(EnableBy || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplyPluginsType,
+  ConfigChangeType,
+  EnableBy,
+  Env,
+  PluginType,
+  ServiceStage
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@4399ywkf/core",
+  "version": "4.0.61",
+  "homepage": "https://github.com/umijs/umi/tree/master/packages/core#readme",
+  "bugs": "https://github.com/umijs/umi/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umijs/umi"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "compiled"
+  ],
+  "dependencies": {
+    "@4399ywkf/bundler-utils": "4.0.61",
+    "@4399ywkf/utils": "4.0.61"
+  },
+  "devDependencies": {
+    "dotenv": "16.0.0",
+    "dotenv-expand": "8.0.3",
+    "just-diff": "5.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "chencheng <sorrycc@gmail.com> (https://github.com/sorrycc)"
+  ],
+  "compiledConfig": {
+    "deps": [
+      "dotenv",
+      "just-diff"
+    ],
+    "externals": {
+      "dotenv": "$$LOCAL",
+      "just-diff": "$$LOCAL",
+      "tapable": "@4399ywkf/bundler-utils/compiled/tapable"
+    }
+  },
+  "scripts": {
+    "build": "umi-scripts father build",
+    "build:deps": "umi-scripts bundleDeps",
+    "dev": "umi-scripts father dev",
+    "test": "umi-scripts jest-turbo"
+  }
+}