@ohbug/core 1.1.5 → 2.0.0

package/README.md

@@ -2,7 +2,6 @@
 
 [![npm](https://img.shields.io/npm/v/@ohbug/core.svg?style=flat-square)](https://www.npmjs.com/package/@ohbug/core)
 [![npm bundle size](https://img.shields.io/bundlephobia/min/@ohbug/core?style=flat-square)](https://bundlephobia.com/result?p=@ohbug/core)
-[![Code style](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
 
 English | [简体中文](./README-zh_CN.md)
 
@@ -13,5 +12,5 @@ ohbug's core module is responsible for managing ohbug's workflow.
 ## Installation
 
 ```
-yarn add @ohbug/core
+pnpm instal @ohbug/core
 ```

package/dist/index.d.ts

@@ -1,4 +1,38 @@
-export { Client } from './client';
-export { createExtension, createExtensionUI } from './extension';
-export { isEvent } from './event';
-//# sourceMappingURL=index.d.ts.map
+import { OhbugClientConstructor, OhbugEventWithMethods, OhbugExtension, OhbugExtensionUI } from '@ohbug/types';
+
+declare const Client: OhbugClientConstructor;
+
+declare function isEvent(eventLike: any): eventLike is OhbugEventWithMethods<any>;
+
+declare function defineExtension(extension: OhbugExtension): OhbugExtension;
+declare function createExtensionUI(extensionUI: OhbugExtensionUI): OhbugExtensionUI;
+
+declare const enum EventTypes {
+    UNCAUGHT_ERROR = "uncaughtError",
+    RESOURCE_ERROR = "resourceError",
+    UNHANDLEDREJECTION_ERROR = "unhandledrejectionError",
+    AJAX_ERROR = "ajaxError",
+    FETCH_ERROR = "fetchError",
+    WEBSOCKET_ERROR = "websocketError",
+    UNKNOWN_ERROR = "unknownError",
+    MESSAGE = "message",
+    FEEDBACK = "feedback",
+    VIEW = "view",
+    REACT = "react",
+    VUE = "vue",
+    ANGULAR = "angular",
+    MINIAPP_ERROR = "miniappError",
+    MINIAPP_UNHANDLEDREJECTION_ERROR = "miniappUnhandledrejectionError",
+    MINIAPP_PAGENOTFOUND_ERROR = "miniappPagenotfoundError",
+    MINIAPP_MEMORYWARNING_ERROR = "miniappMemorywarningError"
+}
+
+type types_EventTypes = EventTypes;
+declare const types_EventTypes: typeof EventTypes;
+declare namespace types {
+  export {
+    types_EventTypes as EventTypes,
+  };
+}
+
+export { Client, EventTypes, createExtensionUI, defineExtension, isEvent, types };

package/dist/index.js

@@ -0,0 +1,495 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Client: () => Client,
+  EventTypes: () => EventTypes,
+  createExtensionUI: () => createExtensionUI,
+  defineExtension: () => defineExtension,
+  isEvent: () => isEvent,
+  types: () => types_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+var import_utils4 = require("@ohbug/utils");
+
+// src/config.ts
+var import_utils = require("@ohbug/utils");
+var schema = {
+  apiKey: {
+    defaultValue: void 0,
+    message: "is required",
+    validate: (value) => Boolean(value) && (0, import_utils.isString)(value)
+  },
+  appVersion: {
+    defaultValue: void 0,
+    message: "should be a string",
+    validate: (value) => value === void 0 || (0, import_utils.isString)(value)
+  },
+  appType: {
+    defaultValue: void 0,
+    message: "should be a string",
+    validate: (value) => value === void 0 || (0, import_utils.isString)(value)
+  },
+  releaseStage: {
+    defaultValue: "production",
+    message: "should be a string",
+    validate: (value) => value === void 0 || (0, import_utils.isString)(value)
+  },
+  endpoint: {
+    defaultValue: "http://localhost:6660",
+    message: "should be a string",
+    validate: (value) => value === void 0 || (0, import_utils.isString)(value)
+  },
+  maxActions: {
+    defaultValue: 30,
+    message: "should be a number between 0 and 100",
+    validate: (value) => value === void 0 || (0, import_utils.isNumber)(value) && value >= 1 && value <= 100
+  },
+  created: {
+    defaultValue: (event) => event,
+    message: "should be a function",
+    validate: (value) => value === void 0 || (0, import_utils.isFunction)(value)
+  },
+  notified: {
+    defaultValue: () => {
+    },
+    message: "should be a function",
+    validate: (value) => value === void 0 || (0, import_utils.isFunction)(value)
+  },
+  logger: {
+    defaultValue: import_utils.logger,
+    message: "should be null or an object with methods { log, info, warn, error }",
+    validate: (value) => value === void 0 || value && ["log", "info", "warn", "error"].reduce((accumulator, method) => accumulator && typeof value[method] === "function", true)
+  },
+  user: {
+    defaultValue: void 0,
+    message: "should be an object and have up to 6 attributes",
+    validate: (value) => value === void 0 || (0, import_utils.isObject)(value) && Object.keys(value).length <= 6
+  },
+  metaData: {
+    defaultValue: void 0,
+    message: "should be an object",
+    validate: (value) => value === void 0 || (0, import_utils.isObject)(value)
+  }
+};
+
+// src/event.ts
+var import_utils2 = require("@ohbug/utils");
+
+// src/action.ts
+var Action = class {
+  type;
+  timestamp;
+  message;
+  data;
+  constructor(message, data, type, timestamp) {
+    this.type = type;
+    this.timestamp = timestamp || new Date().toISOString();
+    this.message = message;
+    this.data = data;
+  }
+};
+
+// src/lib/getErrorMessage.ts
+function getConfigErrorMessage(errors, config) {
+  return new Error(`Invalid configuration
+${Object.keys(errors).map((key) => {
+    return `- ${key} ${errors[key]}, got ${JSON.stringify(config[key])}`;
+  }).join("\n")}
+      `);
+}
+function getErrorMessage(message, data) {
+  return new Error(`Invalid data
+- ${message}, got ${JSON.stringify(data)}`);
+}
+
+// src/lib/metaData.ts
+function addMetaData(map, section, data) {
+  if (!section)
+    return;
+  map[section] = data;
+}
+function getMetaData(map, section) {
+  if (map[section])
+    return map[section];
+  return void 0;
+}
+function deleteMetaData(map, section) {
+  if (map[section])
+    return delete map[section];
+  return void 0;
+}
+
+// src/event.ts
+var Event = class {
+  apiKey;
+  appVersion;
+  appType;
+  timestamp;
+  category;
+  type;
+  sdk;
+  device;
+  detail;
+  user;
+  actions;
+  metaData;
+  releaseStage;
+  __client;
+  constructor(values, client) {
+    const {
+      apiKey,
+      appVersion,
+      appType,
+      releaseStage,
+      timestamp,
+      category,
+      type,
+      sdk,
+      detail,
+      device,
+      user,
+      actions,
+      metaData
+    } = values;
+    this.apiKey = apiKey;
+    this.appVersion = appVersion;
+    this.appType = appType;
+    this.releaseStage = releaseStage;
+    this.timestamp = timestamp;
+    this.category = category;
+    this.type = type;
+    this.sdk = sdk;
+    this.detail = detail;
+    this.device = device;
+    this.user = user;
+    this.actions = actions;
+    this.metaData = metaData != null ? metaData : {};
+    this.__client = client;
+  }
+  get __isOhbugEvent() {
+    return true;
+  }
+  addAction(message, data, type, timestamp) {
+    var _a, _b;
+    const actions = this.actions;
+    const targetMessage = (0, import_utils2.isString)(message) ? message : "";
+    const targetData = data || {};
+    const targetType = (0, import_utils2.isString)(type) ? type : "";
+    const action = new Action(targetMessage, targetData, targetType, timestamp);
+    if (actions.length >= ((_b = (_a = this.__client) == null ? void 0 : _a.__config.maxActions) != null ? _b : 30))
+      actions.shift();
+    actions.push(action);
+  }
+  getUser() {
+    return this.user;
+  }
+  setUser(user) {
+    var _a;
+    if ((0, import_utils2.isObject)(user) && Object.keys(user).length <= 6) {
+      this.user = __spreadValues(__spreadValues({}, this.user), user);
+      return this.getUser();
+    }
+    (_a = this.__client) == null ? void 0 : _a.__logger.error(getErrorMessage("setUser should be an object and have up to 6 attributes", user));
+    return void 0;
+  }
+  addMetaData(section, data) {
+    return addMetaData(this.metaData, section, data);
+  }
+  getMetaData(section) {
+    return getMetaData(this.metaData, section);
+  }
+  deleteMetaData(section) {
+    return deleteMetaData(this.metaData, section);
+  }
+  toJSON() {
+    const {
+      apiKey,
+      appVersion,
+      appType,
+      timestamp,
+      category,
+      type,
+      sdk,
+      device,
+      detail,
+      user,
+      actions,
+      metaData,
+      releaseStage
+    } = this;
+    return {
+      apiKey,
+      appVersion,
+      appType,
+      timestamp,
+      category,
+      type,
+      sdk,
+      device,
+      detail,
+      user,
+      actions,
+      metaData,
+      releaseStage
+    };
+  }
+};
+function createEvent(values, client) {
+  const { apiKey, appVersion, appType, releaseStage } = client.__config;
+  const timestamp = new Date().toISOString();
+  const device = client.__device(client);
+  let category;
+  let type;
+  let detail;
+  if ((0, import_utils2.isObject)(values) && Object.prototype.hasOwnProperty.call(values, "type") && Object.prototype.hasOwnProperty.call(values, "detail")) {
+    category = values.category || "error";
+    type = values.type;
+    detail = values.detail;
+  } else {
+    category = "error";
+    type = "unknownError";
+    detail = values;
+  }
+  return new Event({
+    apiKey,
+    appVersion,
+    appType,
+    timestamp,
+    category,
+    type,
+    sdk: client.__sdk,
+    device,
+    user: client.__user,
+    detail,
+    actions: client.__actions,
+    metaData: client.__metaData,
+    releaseStage
+  }, client);
+}
+function handleEventCreated(event, client) {
+  const funcs = [
+    client.__config.created,
+    ...client.__extensions.map(({ created }) => created)
+  ].filter((v) => (0, import_utils2.isFunction)(v));
+  if (funcs.length === 0)
+    return event;
+  return funcs.reduce((previous, current) => {
+    if (previous && (0, import_utils2.isFunction)(current))
+      return current(previous, client);
+    return null;
+  }, event);
+}
+function isEvent(eventLike) {
+  return Boolean(eventLike == null ? void 0 : eventLike.__isOhbugEvent);
+}
+
+// src/notify.ts
+var import_utils3 = require("@ohbug/utils");
+function handleNotified(event, client) {
+  const funcs = [
+    client.__config.notified,
+    ...client.__extensions.filter(({ notified }) => (0, import_utils3.isFunction)(notified)).map(({ notified }) => notified)
+  ];
+  funcs.forEach((func) => func == null ? void 0 : func(event, client));
+}
+async function notify(event, client) {
+  try {
+    let result = null;
+    if (event) {
+      result = await client.__notifier(event);
+      handleNotified(event, client);
+    }
+    return result;
+  } catch (e) {
+    client.__logger.error(e);
+  }
+}
+
+// src/lib/verifyConfig.ts
+function verifyConfig(config, schema2) {
+  const keys = Object.keys(schema2);
+  return keys.reduce((accumulator, key) => {
+    const configValue = config[key];
+    const { defaultValue, message, validate } = schema2[key];
+    if (configValue !== void 0) {
+      const valid = validate(configValue);
+      if (valid) {
+        accumulator.config[key] = configValue;
+      } else {
+        accumulator.config[key] = defaultValue;
+        accumulator.errors[key] = message;
+      }
+    } else {
+      accumulator.config[key] = defaultValue;
+    }
+    return accumulator;
+  }, {
+    config: {},
+    errors: {}
+  });
+}
+
+// src/client.ts
+var Client = class Client2 {
+  __sdk;
+  __config;
+  __logger;
+  __device;
+  __notifier;
+  __extensions;
+  __actions;
+  __user;
+  __metaData;
+  constructor({
+    sdk,
+    config: baseConfig,
+    schema: schema2 = schema,
+    device,
+    notifier
+  }) {
+    const { config, errors } = verifyConfig(baseConfig, schema2);
+    this.__sdk = sdk;
+    this.__config = config;
+    this.__logger = config.logger;
+    this.__device = device;
+    this.__notifier = notifier;
+    this.__extensions = [];
+    this.__actions = [];
+    this.__user = config.user;
+    this.__metaData = {};
+    if ((0, import_utils4.isObject)(config.metaData)) {
+      Object.keys(config.metaData).forEach((key) => {
+        this.addMetaData(key, config.metaData[key]);
+      });
+    }
+    if (Object.keys(errors).length)
+      this.__logger.warn(getConfigErrorMessage(errors, baseConfig));
+  }
+  use(extension) {
+    var _a;
+    this.__extensions.push(extension);
+    (_a = extension.setup) == null ? void 0 : _a.call(extension, this);
+    return this;
+  }
+  createEvent(value) {
+    const event = createEvent(value, this);
+    return handleEventCreated(event, this);
+  }
+  notify(eventLike, beforeNotify) {
+    let event;
+    if (Boolean(eventLike) && !isEvent(eventLike))
+      event = this.createEvent(eventLike);
+    else
+      event = eventLike;
+    if (beforeNotify)
+      event = beforeNotify(event);
+    return notify(event, this);
+  }
+  addAction(message, data, type, timestamp) {
+    const actions = this.__actions;
+    const targetMessage = (0, import_utils4.isString)(message) ? message : "";
+    const targetData = data || {};
+    const targetType = (0, import_utils4.isString)(type) ? type : "";
+    const action = new Action(targetMessage, targetData, targetType, timestamp);
+    if (actions.length >= this.__config.maxActions)
+      actions.shift();
+    actions.push(action);
+  }
+  getUser() {
+    return this.__user;
+  }
+  setUser(user) {
+    if ((0, import_utils4.isObject)(user) && Object.keys(user).length <= 6) {
+      this.__user = __spreadValues(__spreadValues({}, this.__user), user);
+      return this.getUser();
+    }
+    this.__logger.warn(getErrorMessage("setUser should be an object and have up to 6 attributes", user));
+    return void 0;
+  }
+  addMetaData(section, data) {
+    return addMetaData(this.__metaData, section, data);
+  }
+  getMetaData(section) {
+    return getMetaData(this.__metaData, section);
+  }
+  deleteMetaData(section) {
+    return deleteMetaData(this.__metaData, section);
+  }
+};
+
+// src/extension.ts
+function defineExtension(extension) {
+  return extension;
+}
+function createExtensionUI(extensionUI) {
+  return extensionUI;
+}
+
+// src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  EventTypes: () => EventTypes
+});
+var EventTypes = /* @__PURE__ */ ((EventTypes2) => {
+  EventTypes2["UNCAUGHT_ERROR"] = "uncaughtError";
+  EventTypes2["RESOURCE_ERROR"] = "resourceError";
+  EventTypes2["UNHANDLEDREJECTION_ERROR"] = "unhandledrejectionError";
+  EventTypes2["AJAX_ERROR"] = "ajaxError";
+  EventTypes2["FETCH_ERROR"] = "fetchError";
+  EventTypes2["WEBSOCKET_ERROR"] = "websocketError";
+  EventTypes2["UNKNOWN_ERROR"] = "unknownError";
+  EventTypes2["MESSAGE"] = "message";
+  EventTypes2["FEEDBACK"] = "feedback";
+  EventTypes2["VIEW"] = "view";
+  EventTypes2["REACT"] = "react";
+  EventTypes2["VUE"] = "vue";
+  EventTypes2["ANGULAR"] = "angular";
+  EventTypes2["MINIAPP_ERROR"] = "miniappError";
+  EventTypes2["MINIAPP_UNHANDLEDREJECTION_ERROR"] = "miniappUnhandledrejectionError";
+  EventTypes2["MINIAPP_PAGENOTFOUND_ERROR"] = "miniappPagenotfoundError";
+  EventTypes2["MINIAPP_MEMORYWARNING_ERROR"] = "miniappMemorywarningError";
+  return EventTypes2;
+})(EventTypes || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Client,
+  EventTypes,
+  createExtensionUI,
+  defineExtension,
+  isEvent,
+  types
+});