@doordeck/doordeck-headless-sdk 0.105.0 → 0.107.0

package/kotlin/Kermit-kermit-core.js

@@ -0,0 +1,316 @@
+(function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var protoOf = kotlin_kotlin.$_$.ub;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.a2;
+  var isInterface = kotlin_kotlin.$_$.hb;
+  var Unit_instance = kotlin_kotlin.$_$.k5;
+  var initMetadataForClass = kotlin_kotlin.$_$.sa;
+  var initMetadataForObject = kotlin_kotlin.$_$.ya;
+  var VOID = kotlin_kotlin.$_$.h;
+  var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.j1;
+  var charSequenceLength = kotlin_kotlin.$_$.ha;
+  var initMetadataForInterface = kotlin_kotlin.$_$.wa;
+  var getStringHashCode = kotlin_kotlin.$_$.qa;
+  var THROW_CCE = kotlin_kotlin.$_$.sf;
+  var toList = kotlin_kotlin.$_$.u8;
+  var Enum = kotlin_kotlin.$_$.hf;
+  var objectCreate = kotlin_kotlin.$_$.tb;
+  var stackTraceToString = kotlin_kotlin.$_$.tg;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.rg;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(BaseLogger, 'BaseLogger');
+  initMetadataForClass(LogWriter, 'LogWriter');
+  function formatSeverity(severity) {
+    return severity.toString() + ':';
+  }
+  function formatTag(tag) {
+    return '(' + _Tag___get_tag__impl__7z9hd6(tag) + ')';
+  }
+  function formatMessage(severity, tag, message) {
+    var tmp;
+    if (severity == null) {
+      var tmp_0 = tag;
+      tmp = (tmp_0 == null ? null : new Tag(tmp_0)) == null;
+    } else {
+      tmp = false;
+    }
+    if (tmp)
+      return _Message___get_message__impl__3t69n4(message);
+    var sb = StringBuilder_init_$Create$();
+    if (!(severity == null)) {
+      sb.r8(this.e6g(severity)).r8(' ');
+    }
+    var tmp_1;
+    var tmp_2 = tag;
+    if (!((tmp_2 == null ? null : new Tag(tmp_2)) == null)) {
+      // Inline function 'kotlin.text.isNotEmpty' call
+      var this_0 = _Tag___get_tag__impl__7z9hd6(tag);
+      tmp_1 = charSequenceLength(this_0) > 0;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      sb.r8(this.c6g(tag)).r8(' ');
+    }
+    sb.r8(_Message___get_message__impl__3t69n4(message));
+    return sb.toString();
+  }
+  initMetadataForInterface(MessageStringFormatter, 'MessageStringFormatter');
+  initMetadataForObject(NoTagFormatter, 'NoTagFormatter', VOID, VOID, [MessageStringFormatter]);
+  initMetadataForObject(DefaultFormatter, 'DefaultFormatter', VOID, VOID, [MessageStringFormatter]);
+  initMetadataForClass(Tag, 'Tag');
+  initMetadataForInterface(MutableLoggerConfig, 'MutableLoggerConfig');
+  initMetadataForClass(Severity, 'Severity', VOID, Enum);
+  initMetadataForClass(ConsoleWriter, 'ConsoleWriter', ConsoleWriter_init_$Create$, LogWriter);
+  initMetadataForClass(JsMutableLoggerConfig, 'JsMutableLoggerConfig', VOID, VOID, [MutableLoggerConfig]);
+  initMetadataForObject(ConsoleActual, 'ConsoleActual');
+  //endregion
+  function get_DEFAULT_MIN_SEVERITY() {
+    _init_properties_BaseLogger_kt__lobnq7();
+    return DEFAULT_MIN_SEVERITY;
+  }
+  var DEFAULT_MIN_SEVERITY;
+  function BaseLogger(config) {
+    this.w6f_1 = config;
+  }
+  protoOf(BaseLogger).v3h = function () {
+    return this.w6f_1;
+  };
+  protoOf(BaseLogger).x6f = function () {
+    // Inline function 'kotlin.let' call
+    var it = this.v3h();
+    if (!isInterface(it, MutableLoggerConfig)) {
+      throw IllegalStateException_init_$Create$('Logger config is not mutable');
+    }
+    return it;
+  };
+  protoOf(BaseLogger).y6f = function (severity, tag, throwable, message) {
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = this.v3h().z6f().p();
+    while (_iterator__ex2g4s.q()) {
+      var element = _iterator__ex2g4s.r();
+      if (element.b6g(tag, severity)) {
+        element.a6g(severity, message, tag, throwable);
+      }
+    }
+  };
+  var properties_initialized_BaseLogger_kt_e6qv19;
+  function _init_properties_BaseLogger_kt__lobnq7() {
+    if (!properties_initialized_BaseLogger_kt_e6qv19) {
+      properties_initialized_BaseLogger_kt_e6qv19 = true;
+      DEFAULT_MIN_SEVERITY = Severity_Verbose_getInstance();
+    }
+  }
+  function LogWriter() {
+  }
+  protoOf(LogWriter).b6g = function (tag, severity) {
+    return true;
+  };
+  function NoTagFormatter() {
+  }
+  protoOf(NoTagFormatter).c6g = function (tag) {
+    return '';
+  };
+  protoOf(NoTagFormatter).d6g = function (severity, tag, message) {
+    return formatMessage.call(this, severity, null, message);
+  };
+  var NoTagFormatter_instance;
+  function NoTagFormatter_getInstance() {
+    return NoTagFormatter_instance;
+  }
+  function MessageStringFormatter() {
+  }
+  function DefaultFormatter() {
+  }
+  var DefaultFormatter_instance;
+  function DefaultFormatter_getInstance() {
+    return DefaultFormatter_instance;
+  }
+  function _Tag___init__impl__opaqzl(tag) {
+    return tag;
+  }
+  function _Tag___get_tag__impl__7z9hd6($this) {
+    return $this;
+  }
+  function Tag__toString_impl_tvevk7($this) {
+    return 'Tag(tag=' + $this + ')';
+  }
+  function Tag__hashCode_impl_848yrc($this) {
+    return getStringHashCode($this);
+  }
+  function Tag__equals_impl_6ocp5g($this, other) {
+    if (!(other instanceof Tag))
+      return false;
+    if (!($this === (other instanceof Tag ? other.f6g_1 : THROW_CCE())))
+      return false;
+    return true;
+  }
+  function Tag(tag) {
+    this.f6g_1 = tag;
+  }
+  protoOf(Tag).toString = function () {
+    return Tag__toString_impl_tvevk7(this.f6g_1);
+  };
+  protoOf(Tag).hashCode = function () {
+    return Tag__hashCode_impl_848yrc(this.f6g_1);
+  };
+  protoOf(Tag).equals = function (other) {
+    return Tag__equals_impl_6ocp5g(this.f6g_1, other);
+  };
+  function _Message___init__impl__p3e8y6(message) {
+    return message;
+  }
+  function _Message___get_message__impl__3t69n4($this) {
+    return $this;
+  }
+  function MutableLoggerConfig() {
+  }
+  function mutableLoggerConfigInit(logWriters, minSeverity) {
+    minSeverity = minSeverity === VOID ? get_DEFAULT_MIN_SEVERITY() : minSeverity;
+    // Inline function 'kotlin.also' call
+    var this_0 = mutableLoggerConfigInit_0(toList(logWriters));
+    this_0.g6g(minSeverity);
+    return this_0;
+  }
+  var Severity_Verbose_instance;
+  var Severity_Debug_instance;
+  var Severity_Info_instance;
+  var Severity_Warn_instance;
+  var Severity_Error_instance;
+  var Severity_Assert_instance;
+  var Severity_entriesInitialized;
+  function Severity_initEntries() {
+    if (Severity_entriesInitialized)
+      return Unit_instance;
+    Severity_entriesInitialized = true;
+    Severity_Verbose_instance = new Severity('Verbose', 0);
+    Severity_Debug_instance = new Severity('Debug', 1);
+    Severity_Info_instance = new Severity('Info', 2);
+    Severity_Warn_instance = new Severity('Warn', 3);
+    Severity_Error_instance = new Severity('Error', 4);
+    Severity_Assert_instance = new Severity('Assert', 5);
+  }
+  function Severity(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  function Severity_Verbose_getInstance() {
+    Severity_initEntries();
+    return Severity_Verbose_instance;
+  }
+  function Severity_Debug_getInstance() {
+    Severity_initEntries();
+    return Severity_Debug_instance;
+  }
+  function Severity_Error_getInstance() {
+    Severity_initEntries();
+    return Severity_Error_instance;
+  }
+  function Severity_Assert_getInstance() {
+    Severity_initEntries();
+    return Severity_Assert_instance;
+  }
+  function ConsoleWriter_init_$Init$(messageStringFormatter, $this) {
+    messageStringFormatter = messageStringFormatter === VOID ? DefaultFormatter_instance : messageStringFormatter;
+    ConsoleWriter.call($this, messageStringFormatter, ConsoleActual_instance);
+    return $this;
+  }
+  function ConsoleWriter_init_$Create$(messageStringFormatter) {
+    return ConsoleWriter_init_$Init$(messageStringFormatter, objectCreate(protoOf(ConsoleWriter)));
+  }
+  function ConsoleWriter(messageStringFormatter, console) {
+    LogWriter.call(this);
+    this.h6g_1 = messageStringFormatter;
+    this.i6g_1 = console;
+  }
+  protoOf(ConsoleWriter).a6g = function (severity, message, tag, throwable) {
+    var output = this.h6g_1.d6g(null, _Tag___init__impl__opaqzl(tag), _Message___init__impl__p3e8y6(message));
+    if (throwable == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      output = output + (' ' + stackTraceToString(throwable));
+    }
+    switch (severity.r2_1) {
+      case 5:
+      case 4:
+        this.i6g_1.j6g(output);
+        break;
+      case 3:
+        this.i6g_1.k6g(output);
+        break;
+      case 2:
+        this.i6g_1.l6g(output);
+        break;
+      case 1:
+      case 0:
+        this.i6g_1.n4z(output);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  };
+  function JsMutableLoggerConfig(logWriters) {
+    this.m6g_1 = get_DEFAULT_MIN_SEVERITY();
+    this.n6g_1 = logWriters;
+  }
+  protoOf(JsMutableLoggerConfig).g6g = function (_set____db54di) {
+    this.m6g_1 = _set____db54di;
+  };
+  protoOf(JsMutableLoggerConfig).o6g = function () {
+    return this.m6g_1;
+  };
+  protoOf(JsMutableLoggerConfig).z6f = function () {
+    return this.n6g_1;
+  };
+  function mutableLoggerConfigInit_0(logWriters) {
+    return new JsMutableLoggerConfig(logWriters);
+  }
+  function platformLogWriter(messageStringFormatter) {
+    messageStringFormatter = messageStringFormatter === VOID ? DefaultFormatter_instance : messageStringFormatter;
+    return ConsoleWriter_init_$Create$();
+  }
+  function ConsoleActual() {
+  }
+  protoOf(ConsoleActual).j6g = function (output) {
+    console.error(output);
+  };
+  protoOf(ConsoleActual).k6g = function (output) {
+    console.warn(output);
+  };
+  protoOf(ConsoleActual).l6g = function (output) {
+    console.info(output);
+  };
+  protoOf(ConsoleActual).n4z = function (output) {
+    console.log(output);
+  };
+  var ConsoleActual_instance;
+  function ConsoleActual_getInstance() {
+    return ConsoleActual_instance;
+  }
+  //region block: post-declaration
+  protoOf(NoTagFormatter).e6g = formatSeverity;
+  protoOf(DefaultFormatter).e6g = formatSeverity;
+  protoOf(DefaultFormatter).c6g = formatTag;
+  protoOf(DefaultFormatter).d6g = formatMessage;
+  //endregion
+  //region block: init
+  NoTagFormatter_instance = new NoTagFormatter();
+  DefaultFormatter_instance = new DefaultFormatter();
+  ConsoleActual_instance = new ConsoleActual();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = BaseLogger;
+  _.$_$.b = mutableLoggerConfigInit;
+  _.$_$.c = mutableLoggerConfigInit_0;
+  _.$_$.d = platformLogWriter;
+  _.$_$.e = Severity_Assert_getInstance;
+  _.$_$.f = Severity_Debug_getInstance;
+  _.$_$.g = Severity_Error_getInstance;
+  _.$_$.h = NoTagFormatter_instance;
+  //endregion
+  return _;
+}(module.exports, require('./kotlin-kotlin-stdlib.js')));

package/kotlin/Kermit-kermit.js

@@ -0,0 +1,51 @@
+(function (_, kotlin_co_touchlab_kermit_core, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var platformLogWriter = kotlin_co_touchlab_kermit_core.$_$.d;
+  var listOf = kotlin_kotlin.$_$.v7;
+  var mutableLoggerConfigInit = kotlin_co_touchlab_kermit_core.$_$.c;
+  var protoOf = kotlin_kotlin.$_$.ub;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.ta;
+  var BaseLogger = kotlin_co_touchlab_kermit_core.$_$.a;
+  var VOID = kotlin_kotlin.$_$.h;
+  var initMetadataForClass = kotlin_kotlin.$_$.sa;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(Logger, 'Logger', VOID, BaseLogger);
+  initMetadataForCompanion(Companion, Logger);
+  //endregion
+  function Companion() {
+    Companion_instance = this;
+    Logger.call(this, mutableLoggerConfigInit(listOf(platformLogWriter())), '');
+  }
+  protoOf(Companion).r6g = function () {
+    return get_defaultTag();
+  };
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Logger(config, tag) {
+    Companion_getInstance();
+    tag = tag === VOID ? '' : tag;
+    BaseLogger.call(this, config);
+    this.t6g_1 = tag;
+  }
+  protoOf(Logger).r6g = function () {
+    return this.t6g_1;
+  };
+  function get_defaultTag() {
+    return defaultTag;
+  }
+  var defaultTag;
+  //region block: init
+  defaultTag = '';
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Logger;
+  //endregion
+  return _;
+}(module.exports, require('./Kermit-kermit-core.js'), require('./kotlin-kotlin-stdlib.js')));