agora-foundation 1.0.0

package/lib/decorator/bound/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Binds correct instance to `this`.
+ * Note: put it to first before all other annotations in order to take effect.
+ */
+export declare const bound: (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/lib/decorator/bound/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bound = void 0;
+require("core-js/modules/es.function.bind.js");
+require("core-js/modules/es.function.name.js");
+/**
+ * Binds correct instance to `this`.
+ * Note: put it to first before all other annotations in order to take effect.
+ */
+var bound = exports.bound = function bound(originalMethod, context) {
+  context.addInitializer(function () {
+    //@ts-ignore
+    this[context.name] = this[context.name].bind(this);
+  });
+};

package/lib/decorator/index.d.ts

@@ -0,0 +1,3 @@
+export { trace } from './log';
+export { bound } from './bound';
+export { debounced, throttled } from './lodash';

package/lib/decorator/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "bound", {
+  enumerable: true,
+  get: function get() {
+    return _bound.bound;
+  }
+});
+Object.defineProperty(exports, "debounced", {
+  enumerable: true,
+  get: function get() {
+    return _lodash.debounced;
+  }
+});
+Object.defineProperty(exports, "throttled", {
+  enumerable: true,
+  get: function get() {
+    return _lodash.throttled;
+  }
+});
+Object.defineProperty(exports, "trace", {
+  enumerable: true,
+  get: function get() {
+    return _log.trace;
+  }
+});
+var _log = require("./log");
+var _bound = require("./bound");
+var _lodash = require("./lodash");

package/lib/decorator/lodash/index.d.ts

@@ -0,0 +1,16 @@
+import type { DebounceSettings, ThrottleSettings } from 'lodash';
+export declare const cleanup: () => void;
+/**
+ * Makes methods debounced
+ * @param wait
+ * @param options
+ * @returns
+ */
+export declare const debounced: (wait?: number, options?: DebounceSettings) => (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Makes methods throttled
+ * @param wait
+ * @param options
+ * @returns
+ */
+export declare const throttled: (wait?: number, options?: ThrottleSettings) => (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/lib/decorator/lodash/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.throttled = exports.debounced = exports.cleanup = void 0;
+require("core-js/modules/es.function.name.js");
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+var _throttle = _interopRequireDefault(require("lodash/throttle"));
+var cleanup = exports.cleanup = function cleanup() {};
+
+/**
+ * Makes methods debounced
+ * @param wait
+ * @param options
+ * @returns
+ */
+var debounced = exports.debounced = function debounced(wait, options) {
+  return function (originalMethod, context) {
+    context.addInitializer(function () {
+      //@ts-ignore
+      this[context.name] = (0, _debounce["default"])(this[context.name], wait, options);
+    });
+  };
+};
+
+/**
+ * Makes methods throttled
+ * @param wait
+ * @param options
+ * @returns
+ */
+var throttled = exports.throttled = function throttled(wait, options) {
+  return function (originalMethod, context) {
+    context.addInitializer(function () {
+      //@ts-ignore
+      this[context.name] = (0, _throttle["default"])(this[context.name], wait, options);
+    });
+  };
+};

package/lib/decorator/log/handler.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '../../logger';
+import { Result } from '../../utilities/interceptor';
+import { InvocationEvent } from '../type';
+export declare const createLogHandler: (logger: Logger) => (evt: InvocationEvent) => Result;

package/lib/decorator/log/handler.js

@@ -0,0 +1,63 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLogHandler = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.function.name.js");
+var _interceptor = require("../../utilities/interceptor");
+var _misc = require("../../utilities/misc");
+var _type = require("../type");
+var _logSerializer = require("./log-serializer");
+var formatCallLog = function formatCallLog(identifier, args) {
+  var msg = '';
+  if (args.length) {
+    msg += "[parameters: ".concat((0, _logSerializer.serializeArgs)(args), "]");
+  }
+  return "".concat(identifier.className, " ").concat(identifier.methodName, " [API Call] ").concat(identifier.traceId, " ").concat(msg);
+};
+var formatReturnLog = function formatReturnLog(identifier, elapsed, args, returnValue, thrown) {
+  var msg = '';
+  if (args !== null && args !== void 0 && args.length) {
+    msg += "[parameters: ".concat((0, _logSerializer.serializeArgs)(args), "]");
+  }
+  if (thrown) {
+    msg += "[throw: ".concat(thrown.name, "]");
+    msg += "[message: ".concat(thrown.message, "]");
+  } else if (typeof returnValue !== 'undefined') {
+    msg += "[return: ".concat((0, _logSerializer.serialize)(returnValue), "]");
+  }
+  return "".concat(identifier.className, " ").concat(identifier.methodName, " [API Call]").concat(msg, "[elapsed: ").concat(elapsed, "ms]");
+};
+var createLogHandler = exports.createLogHandler = function createLogHandler(logger) {
+  return function (evt) {
+    if (evt.type === _type.InvocationEventType.PRE) {
+      evt.context.start = new Date().getTime();
+      evt.context.traceId = (0, _misc.randomString)(5);
+
+      // const args = evt.arguments ?? [];
+      // const msg = formatCallLog(
+      //   {
+      //     className: evt.class,
+      //     methodName: evt.method,
+      //     traceId: evt.context.traceId,
+      //   },
+      //   args,
+      // );
+      // logger.info(msg);
+    } else {
+      var _evt$arguments;
+      var elapsed = new Date().getTime() - evt.context.start;
+      var msg = formatReturnLog({
+        className: evt["class"],
+        methodName: evt.method,
+        traceId: evt.context.traceId
+      }, elapsed, (_evt$arguments = evt.arguments) !== null && _evt$arguments !== void 0 ? _evt$arguments : [], evt["return"], evt.error);
+      logger.info(msg);
+    }
+    return _interceptor.Result.CONTINUE;
+  };
+};

package/lib/decorator/log/index.d.ts

@@ -0,0 +1,4 @@
+export declare const trace: {
+    (originalMethod: any, context: ClassMethodDecoratorContext): void;
+    to(label: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+};

package/lib/decorator/log/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trace = void 0;
+require("core-js/modules/es.function.name.js");
+var _proxy = require("../proxy");
+var _handler = require("./handler");
+var _logger = require("../../logger");
+/**
+ * Enables logging for invocation detail of the target method.
+ * @param targetOrProto The class or prototype that the method belongs to.
+ * @param methodName The name of the method.
+ */
+var _trace = function _trace(originalMethod, context) {
+  var methodName = String(context.name);
+  if (context.kind === 'method') {
+    context.addInitializer(function () {
+      var handler = (0, _handler.createLogHandler)((0, _logger.getLogger)('default'));
+      this[context.name] = (0, _proxy.proxyMethod)(this[context.name], this, methodName, handler);
+    });
+  }
+};
+_trace.to = function (label) {
+  var logger = (0, _logger.getLogger)(label);
+  return function (originalMethod, context) {
+    var methodName = String(context.name);
+    if (context.kind === 'method') {
+      context.addInitializer(function () {
+        var handler = (0, _handler.createLogHandler)(logger);
+        this[context.name] = (0, _proxy.proxyMethod)(this[context.name], this, methodName, handler);
+      });
+    }
+  };
+};
+var trace = exports.trace = _trace;

package/lib/decorator/log/log-serializer.d.ts

@@ -0,0 +1,8 @@
+interface Serializer {
+    match(obj: any): boolean;
+    serialize(obj: any): string;
+}
+export declare const addSerializer: (serializer: Serializer) => void;
+export declare const serialize: (data: unknown) => string;
+export declare const serializeArgs: (args: unknown[]) => string;
+export {};

package/lib/decorator/log/log-serializer.js

@@ -0,0 +1,67 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeArgs = exports.serialize = exports.addSerializer = void 0;
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.join.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.match.js");
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+var _misc = require("../../utilities/misc");
+var serializers = [];
+var fileSerializer = {
+  match: function match(obj) {
+    return obj instanceof File;
+  },
+  serialize: function serialize(file) {
+    return (0, _misc.jsonstring)({
+      filename: file.name,
+      size: file.size
+    });
+  }
+};
+var plainObjectSerializer = {
+  match: function match(obj) {
+    return (0, _isPlainObject["default"])(obj);
+  },
+  serialize: function serialize(obj) {
+    return (0, _misc.jsonstring)(obj);
+  }
+};
+var functionSerializer = {
+  match: function match(obj) {
+    return typeof obj === 'function';
+  },
+  serialize: function serialize(obj) {
+    return '[Function]';
+  }
+};
+var addSerializer = exports.addSerializer = function addSerializer(serializer) {
+  serializers.push(serializer);
+};
+var serialize = exports.serialize = function serialize(data) {
+  if (typeof data === 'string') {
+    return data;
+  }
+  var serializer = serializers.find(function (serializer) {
+    return serializer.match(data);
+  });
+  if (serializer) {
+    return serializer.serialize(data);
+  }
+  return "".concat(data);
+};
+var serializeArgs = exports.serializeArgs = function serializeArgs(args) {
+  return "".concat(args.map(serialize).join(' '));
+};
+addSerializer(fileSerializer);
+addSerializer(plainObjectSerializer);
+addSerializer(functionSerializer);

package/lib/decorator/proxy.d.ts

@@ -0,0 +1,9 @@
+import { AnyFunction, InvocationHandler } from './type';
+export declare const proxyMethod: (method: AnyFunction, proto: any, propertyName: string, handler: InvocationHandler) => (this: any, ...args: any[]) => any;
+export declare const extendConstructor: (constructor: any, handler: InvocationHandler, extendProps?: any, proxyMethods?: boolean) => {
+    new (...args: unknown[]): {
+        [x: string]: any;
+    };
+    [x: string]: any;
+    readonly __$$className: any;
+};

package/lib/decorator/proxy.js

@@ -0,0 +1,154 @@
+"use strict";
+
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.proxyMethod = exports.extendConstructor = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-names.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.promise.finally.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _type = require("./type");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var failQuitely = function failQuitely(func, args) {
+  try {
+    return func.apply(void 0, (0, _toConsumableArray2["default"])(args));
+  } catch (e) {}
+};
+var invokeMethod = function invokeMethod(instance, method, proto, propertyName, args, hanlder) {
+  var context = {};
+  failQuitely(hanlder, [{
+    type: _type.InvocationEventType.PRE,
+    arguments: args,
+    method: propertyName,
+    "class": proto.constructor.__$$className || proto.constructor.name,
+    context: context
+  }]);
+
+  // provide a way for invoking method regardless it is async or sync function, attach the return value and the error(if it occurred) to the event object
+  var returnVal = method.apply(instance, args);
+  var post = function post(val, error) {
+    failQuitely(hanlder, [{
+      type: _type.InvocationEventType.POST,
+      arguments: args,
+      "return": val,
+      method: propertyName,
+      "class": proto.constructor.__$$className || proto.constructor.name,
+      context: context,
+      error: error
+    }]);
+  };
+  var isThenable = returnVal && !!returnVal.then;
+  if (isThenable) {
+    // capture async return and potential error
+    var rtnTemp, errTemp;
+    returnVal.then(function (r) {
+      rtnTemp = r;
+    })["catch"](function (e) {
+      errTemp = e;
+    })["finally"](function () {
+      post(rtnTemp, errTemp);
+    });
+  } else {
+    post(returnVal);
+  }
+  return returnVal;
+};
+var proxyMethod = exports.proxyMethod = function proxyMethod(method, proto, propertyName, handler) {
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return invokeMethod(this, method, proto, propertyName, args, handler);
+  };
+};
+var getMethods = function getMethods(target) {
+  var allProps = [];
+  var allMethods = [];
+  var curr = target;
+  while ((curr = Object.getPrototypeOf(curr)) && curr !== Object.prototype) {
+    var props = Object.getOwnPropertyNames(curr);
+    props.forEach(function (prop) {
+      if (allProps.indexOf(prop) === -1) {
+        allProps.push(prop);
+        if (prop === 'constructor') {
+          return;
+        }
+        try {
+          if (typeof target[prop] === 'function') {
+            allMethods.push(prop);
+          }
+        } catch (e) {
+          var descptor = Object.getOwnPropertyDescriptor(curr, prop);
+          if (typeof (descptor === null || descptor === void 0 ? void 0 : descptor.value) === 'function') {
+            // it's a method of a class
+            allMethods.push(prop);
+          } else {
+            // Logger.info('undetermined type of property', descptor, curr, prop);
+          }
+        }
+      }
+    });
+  }
+  return allMethods;
+};
+var extendConstructor = exports.extendConstructor = function extendConstructor(constructor, handler, extendProps, proxyMethods) {
+  var _Class;
+  return _Class = /*#__PURE__*/function (_constructor) {
+    function _Class() {
+      var _this;
+      (0, _classCallCheck2["default"])(this, _Class);
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      _this = _callSuper(this, _Class, [].concat(args));
+      if (proxyMethods) {
+        var methods = getMethods(_this);
+        // proxy methods
+        // redefine methods on the instance
+        methods.forEach(function (propertyName) {
+          var method = _this[propertyName];
+          Object.defineProperty(_this, propertyName, {
+            writable: true,
+            configurable: true,
+            enumerable: false,
+            value: proxyMethod(method, _this, propertyName, handler)
+          });
+        });
+      }
+
+      // mount extend properties
+      Object.keys(extendProps).forEach(function (propertyName) {
+        Object.defineProperty(_this, propertyName, {
+          configurable: true,
+          enumerable: false,
+          writable: false,
+          value: extendProps[propertyName]
+        });
+      });
+      return _this;
+    }
+    (0, _inherits2["default"])(_Class, _constructor);
+    return (0, _createClass2["default"])(_Class);
+  }(constructor), (0, _defineProperty2["default"])(_Class, "__$$className", constructor.name), _Class;
+};

package/lib/decorator/type.d.ts

@@ -0,0 +1,16 @@
+import { Interceptor } from '../utilities/interceptor';
+export declare enum InvocationEventType {
+    PRE = 0,
+    POST = 1
+}
+export type InvocationEvent = {
+    type: InvocationEventType;
+    context: Record<string, any>;
+    class: string;
+    method: string;
+    arguments?: any[];
+    return?: any;
+    error?: Error;
+};
+export type InvocationHandler = Interceptor<InvocationEvent>;
+export type AnyFunction = (...args: any) => any;

package/lib/decorator/type.js

@@ -0,0 +1,12 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InvocationEventType = void 0;
+var InvocationEventType = exports.InvocationEventType = /*#__PURE__*/function (InvocationEventType) {
+  InvocationEventType[InvocationEventType["PRE"] = 0] = "PRE";
+  InvocationEventType[InvocationEventType["POST"] = 1] = "POST";
+  return InvocationEventType;
+}({}); // make it interceptable

package/lib/logger/constants.d.ts

@@ -0,0 +1,11 @@
+import { LogLevel } from './type';
+export declare const logLevelMap: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    debug: LogLevel;
+    info: LogLevel;
+    warn: LogLevel;
+    error: LogLevel;
+};

package/lib/logger/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logLevelMap = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _type = require("./type");
+var logLevelMap = exports.logLevelMap = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _type.LogLevel.ERROR, 'error'), _type.LogLevel.WARN, 'warn'), _type.LogLevel.INFO, 'info'), _type.LogLevel.DEBUG, 'debug'), "debug", _type.LogLevel.DEBUG), "info", _type.LogLevel.INFO), "warn", _type.LogLevel.WARN), "error", _type.LogLevel.ERROR);

package/lib/logger/hijack.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from './type';
+export declare const originConsole: Console;
+export declare const setupConsoleHijack: (logger: Logger) => void;
+export declare const restoreConsoleHijack: () => void;

package/lib/logger/hijack.js

@@ -0,0 +1,65 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.object.define-properties.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupConsoleHijack = exports.restoreConsoleHijack = exports.originConsole = void 0;
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var methods = ['info', 'error', 'warn', 'debug'];
+var originConsole = exports.originConsole = window.console;
+var setupConsoleHijack = exports.setupConsoleHijack = function setupConsoleHijack(logger) {
+  var console = _objectSpread({}, originConsole);
+  //@ts-ignore
+  if (console.__hijackSetup) {
+    console.log('[logger] hijack already setup!');
+    return;
+  }
+  console.log("[logger] setup hijack..");
+  function proxy(methodName) {
+    return function () {
+      switch (methodName) {
+        case 'debug':
+          logger.debug.apply(logger, arguments);
+          break;
+        case 'info':
+          logger.info.apply(logger, arguments);
+          break;
+        case 'warn':
+          logger.warn.apply(logger, arguments);
+          break;
+        case 'error':
+          logger.error.apply(logger, arguments);
+          break;
+      }
+    };
+  }
+  Object.keys(console).filter(function (e) {
+    return methods.indexOf(e) >= 0;
+  }).forEach(function (methodName) {
+    console[methodName] = proxy(methodName);
+  });
+  //@ts-ignore
+  console.__hijackSetup = true;
+  window.console = console;
+};
+var restoreConsoleHijack = exports.restoreConsoleHijack = function restoreConsoleHijack() {
+  console.log("[logger] restore hijack..");
+  window.console = originConsole;
+  //@ts-ignore
+  console.__hijackSetup = false;
+};

package/lib/logger/index.d.ts

@@ -0,0 +1,8 @@
+import { LogLevel, Logger, LogManager } from "./type";
+export declare const getLogger: (label?: string) => Logger;
+export declare const getLogManager: () => LogManager;
+export declare const setLogLevel: (_logLevel: LogLevel) => void;
+export { LogLevel } from "./type";
+export type { LogManager, Logger } from "./type";
+export { restoreConsoleHijack, setupConsoleHijack } from "./hijack";
+export { logLevelMap } from "./constants";