@vonage/client-sdk 0.1.3-alpha.10

package/LICENSE

@@ -0,0 +1,3 @@
+# Commercial license
+
+Please find full and up to date license text at the folling URL: [https://www.vonage.com/legal/communications-apis/terms-of-use/](https://www.vonage.com/legal/communications-apis/terms-of-use/)

package/README.md

@@ -0,0 +1,24 @@
+# Vonage Voice SDK
+
+## Install
+
+### 1. Create a Personal Access Token
+
+- generate token, see [here](https://docs.github.com/en/enterprise-server@3.4/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token ), you will need a PAT with `packages:read` scope enabled 
+- enable SSO for new token, see [here](https://docs.github.com/en/enterprise-cloud@latest/authentication/authenticating-with-saml-single-sign-on/authorizing-a-personal-access-token-for-use-with-saml-single-sign-on)
+
+### 2. Authenticate with Github packages
+
+```
+$ npm login --scope=@nexmoinc --registry=https://npm.pkg.github.com
+
+> Username: USERNAME //github user
+> Password: TOKEN // Personal access token
+> Email: github email 
+```
+
+### 3. Add dependency 
+
+```
+npm install @nexmoinc/voice-sdk
+```

package/dist/Client.d.ts

@@ -0,0 +1,17 @@
+import { vonage } from './kotlin/clientsdk-clientcore_js';
+import './coreExtend';
+import './global';
+/**
+ * Minimal Interface built on top of KMP export
+ * DO NOT ADD CODE HERE UNLESS REALLY NEEDEED!!111!
+ */
+export declare type VonageEvent = vonage.CoreClientEvents;
+export declare type Invite = vonage.VoiceInviteJS;
+export declare type VoiceCall = vonage.VoiceCallJS;
+export declare type Conversation = vonage.ConversationJS;
+declare class VoiceClient extends vonage.CoreClientJS {
+    private callbacks;
+    constructor();
+    on<T extends keyof VonageEvent, Fn extends VonageEvent[T]>(event: T, callback: Fn): void;
+}
+export default VoiceClient;

package/dist/Client.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clientsdk_clientcore_js_1 = require("./kotlin/clientsdk-clientcore_js");
+require("./coreExtend");
+const HttpClient_1 = require("./HttpClient");
+const MediaClient_1 = require("./MediaClient");
+const SocketClient_1 = require("./SocketClient");
+require("./global");
+class VoiceClient extends clientsdk_clientcore_js_1.vonage.CoreClientJS {
+    constructor() {
+        super(new HttpClient_1.default(), new SocketClient_1.default(), new MediaClient_1.default());
+        this.callbacks = new Map();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        this.emitter = new Proxy(Object(), {
+            get(_, prop) {
+                // NOTE: with great power comes great responsiblity ...
+                // We skip ts checks here, but enforce safety via on() generic type constraints.
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                return _this.callbacks.get(prop) || (() => { });
+            }
+        });
+    }
+    on(event, callback) {
+        this.callbacks.set(event, callback);
+    }
+}
+exports.default = VoiceClient;

package/dist/HttpClient.d.ts

@@ -0,0 +1,8 @@
+import * as KMPPackage from './kotlin/clientsdk-clientcore_js';
+import { vonage } from './kotlin/clientsdk-clientcore_js';
+declare type HttpHeaders = Record<string, string | number | boolean>;
+declare class HttpClient implements vonage.HttpClientJS {
+    private stringToVerb;
+    request(verb: string, url: string, headers: HttpHeaders, body: string | null, callback: (p0: KMPPackage.Nullable<Error>, p1: KMPPackage.Nullable<string>) => void): Promise<void>;
+}
+export default HttpClient;

package/dist/HttpClient.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+class HttpClient {
+    stringToVerb(m) {
+        if (m.toLowerCase() === 'get')
+            return 'GET';
+        else if (m.toLowerCase() === 'post')
+            return 'POST';
+        else if (m.toLowerCase() === 'patch')
+            return 'PATCH';
+        else if (m.toLowerCase() === 'put')
+            return 'PUT';
+        else if (m.toLowerCase() === 'options')
+            return 'OPTIONS';
+        else if (m.toLowerCase() === 'delete')
+            return 'DELETE';
+        else
+            return 'GET';
+    }
+    request(verb, url, headers, body, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const method = this.stringToVerb(verb);
+            const data = body !== null && body.length > 0 ? JSON.parse(body) : '';
+            const axiosReq = {
+                url,
+                method,
+                headers,
+                data
+            };
+            try {
+                const res = yield (0, axios_1.default)(axiosReq);
+                console.log(`[JS response]: `, res.data);
+                callback(null, JSON.stringify(res.data));
+            }
+            catch (error) {
+                // let errorMessage: string = '';
+                // let errorStack: string = '';
+                let e = Error('');
+                if (error instanceof Error) {
+                    // errorMessage = error.message;
+                    // errorStack = error.stack;
+                    e = error;
+                }
+                callback(e, null);
+            }
+        });
+    }
+}
+exports.default = HttpClient;

package/dist/MediaClient.d.ts

@@ -0,0 +1,16 @@
+import * as KMPPackage from './kotlin/clientsdk-clientcore_js';
+import { vonage } from './kotlin/clientsdk-clientcore_js';
+declare class MediaClient implements vonage.MediaClientJS {
+    delegate: KMPPackage.Nullable<vonage.MediaClientDelegateJS>;
+    private pcs;
+    private audio;
+    private stream;
+    constructor();
+    enableMedia(id: string, remoteDescription?: string): Promise<void>;
+    mute(id: string): Promise<void>;
+    unmute(id: string): Promise<void>;
+    processAnswer(id: string, sdp: string, streamId: string, legId: string): void;
+    disableMedia(id: string): void;
+    private setMediaTracksEnabled;
+}
+export default MediaClient;

package/dist/MediaClient.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRtcAudioConnection_1 = require("./utils/createRtcAudioConnection");
+class MediaClient {
+    constructor() {
+        this.pcs = new Map();
+        this.audio = undefined;
+    }
+    enableMedia(id, remoteDescription) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const pc = yield (0, createRtcAudioConnection_1.createRtcAudioConnection)();
+                this.pcs.set(id, pc);
+                pc.ontrack = (evt) => {
+                    const stream = evt.streams[0];
+                    if (stream) {
+                        const audio = new Audio();
+                        audio.srcObject = stream;
+                        audio.autoplay = true;
+                        this.audio = audio;
+                        this.stream = stream;
+                    }
+                };
+                if (remoteDescription) {
+                    const sdp = yield (0, createRtcAudioConnection_1.createAnswer)(pc, remoteDescription);
+                    // eslint-disable-next-line @typescript-eslint/no-empty-function
+                    (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.onAnswer(id, '', sdp, () => { });
+                }
+                else {
+                    const sdp = yield (0, createRtcAudioConnection_1.createOffer)(pc);
+                    (_b = this.delegate) === null || _b === void 0 ? void 0 : _b.onOffer(id, '', sdp, () => {
+                        // Do we need to save the leg id for later?
+                    });
+                }
+            }
+            catch (error) {
+                // TODO
+            }
+        });
+    }
+    mute(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setMediaTracksEnabled(id, false);
+        });
+    }
+    unmute(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setMediaTracksEnabled(id, true);
+        });
+    }
+    // async getLocalStream(): Promise<MediaStream> {
+    //   return await navigator.mediaDevices.getUserMedia({
+    //     video: false,
+    //     audio: true
+    //   });
+    // }
+    processAnswer(id, sdp, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    streamId, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    legId) {
+        const remoteDescription = new RTCSessionDescription({
+            type: 'answer',
+            sdp
+        });
+        const pc = this.pcs.get(id);
+        if (pc) {
+            pc.setRemoteDescription(remoteDescription);
+        }
+    }
+    disableMedia(id) {
+        const peerConnection = this.pcs.get(id);
+        if (peerConnection) {
+            peerConnection.close();
+            this.pcs.delete(id);
+        }
+        else {
+            throw new Error('No RTCPeerConnection established');
+        }
+    }
+    // Private Methods
+    setMediaTracksEnabled(id, value) {
+        const pc = this.pcs.get(id);
+        const transceiver = pc === null || pc === void 0 ? void 0 : pc.getTransceivers();
+        const tracks = transceiver === null || transceiver === void 0 ? void 0 : transceiver.map((t) => t.sender.track);
+        tracks === null || tracks === void 0 ? void 0 : tracks.forEach((t) => {
+            if (t) {
+                t.enabled = value;
+            }
+        });
+    }
+}
+exports.default = MediaClient;

package/dist/SocketClient.d.ts

@@ -0,0 +1,12 @@
+import * as KMPPackage from './kotlin/clientsdk-clientcore_js';
+import { vonage } from './kotlin/clientsdk-clientcore_js';
+declare class SocketClient implements vonage.SocketClientJS {
+    delegate: KMPPackage.Nullable<vonage.SocketClientDelegateJS>;
+    private socket;
+    emit(type: string, msg: unknown, _callback: (p0: KMPPackage.Nullable<Error>, p1: KMPPackage.Nullable<string>) => void): void;
+    connect(host: string, path: string, reconnectionAttempts: number, reconnectionDelay: number, randomizationFactor: number, query: string): void;
+    disconnect(): void;
+    startVerifyResponseTimer(milliseconds: number, callback: () => void): void;
+    setConnectParamsSocketConfig(token: string): void;
+}
+export default SocketClient;

package/dist/SocketClient.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clientsdk_clientcore_js_1 = require("./kotlin/clientsdk-clientcore_js");
+const socket_io = require("socket.io-client");
+// import { SocketConfig } from './NexmoClient';
+class SocketClient {
+    emit(type, msg, _callback) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.emit(type, msg);
+        _callback(null, ''); // WHAT DO I NEED TODO HERE?
+    }
+    connect(host, path, reconnectionAttempts, reconnectionDelay, randomizationFactor, query) {
+        const config = {
+            transports: ['websocket'],
+            autoConnect: true,
+            reconnection: true,
+            forceNew: true,
+            path,
+            reconnectionAttempts,
+            reconnectionDelay,
+            randomizationFactor,
+            query
+        };
+        this.socket = socket_io.connect(host, config);
+        this.socket.on('connect', () => {
+            var _a;
+            (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.didReceiveNewSocketConnectionStatusEvent(clientsdk_clientcore_js_1.vonage.SOCKET_CONNECTED, null);
+        });
+        this.socket.on('reconnect_attempt', () => {
+            var _a;
+            (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.didReceiveNewSocketConnectionStatusEvent(clientsdk_clientcore_js_1.vonage.SOCKET_RECONNECTING, null);
+        });
+        this.socket.on('reconnect_failed', () => {
+            var _a;
+            (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.didReceiveNewSocketConnectionStatusEvent(clientsdk_clientcore_js_1.vonage.SOCKET_DISCONNECTED, clientsdk_clientcore_js_1.vonage.REASON_CLIENT_NETWORK_ERROR);
+        });
+        this.socket.on('disconnect', (reason) => {
+            var _a, _b;
+            console.log({ reason });
+            if (reason === 'io client disconnect') {
+                (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.didReceiveNewSocketConnectionStatusEvent(clientsdk_clientcore_js_1.vonage.SOCKET_DISCONNECTED, clientsdk_clientcore_js_1.vonage.REASON_CLIENT_DISCONNECTED);
+            }
+            else if (reason === 'io server disconnect') {
+                (_b = this.delegate) === null || _b === void 0 ? void 0 : _b.didReceiveNewSocketConnectionStatusEvent(clientsdk_clientcore_js_1.vonage.SOCKET_DISCONNECTED, clientsdk_clientcore_js_1.vonage.REASON_SERVER_DISCONNECTED);
+            }
+        });
+        this.socket.io.on('packet', (packet) => {
+            var _a;
+            if (packet.type !== 2)
+                return;
+            if (packet.data[0] === 'echo')
+                return; // ignore echo event
+            const [type, body] = packet.data;
+            if (typeof type == 'string' && body instanceof Object) {
+                (_a = this.delegate) === null || _a === void 0 ? void 0 : _a.didReceiveNewSocketEvent(type, JSON.stringify(body));
+            }
+        });
+    }
+    disconnect() {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.disconnect();
+    }
+    startVerifyResponseTimer(milliseconds, callback) {
+        console.log(`startVerifyResponseTimer: ${milliseconds}`);
+        setTimeout(() => {
+            callback();
+        }, milliseconds);
+    }
+    setConnectParamsSocketConfig(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    token) {
+        if (this.socket) {
+            this.socket.io.opts.query = {
+                token: token
+            };
+        }
+    }
+}
+exports.default = SocketClient;

package/dist/coreExtend.d.ts

@@ -0,0 +1,10 @@
+import './kotlin/clientsdk-clientcore_js';
+declare module './kotlin/clientsdk-clientcore_js' {
+    namespace vonage {
+        interface VoiceCallJS {
+            say(params: Partial<CallSayParams> & {
+                text: string;
+            }): Promise<unknown>;
+        }
+    }
+}

package/dist/coreExtend.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./kotlin/clientsdk-clientcore_js");

package/dist/global.d.ts

@@ -0,0 +1,7 @@
+declare global {
+    type JsonValue = object | null | boolean | string | number;
+    type Json = {
+        [property: string]: Json | JsonValue;
+    } | Json[];
+}
+export {};

package/dist/global.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import './coreExtend';
+export { default as VoiceClient, Invite, VoiceCall, Conversation } from './Client';
+export {} from './coreExtend';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceClient = void 0;
+// export { Vonage } from './kotlin/clientsdk-core_js';
+require("./coreExtend");
+var Client_1 = require("./Client");
+Object.defineProperty(exports, "VoiceClient", { enumerable: true, get: function () { return Client_1.default; } });

package/dist/kotlin/Kermit-kermit-js-ir.js

@@ -0,0 +1,263 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib-js-ir.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'));
+  else {
+    if (typeof this['kotlin-kotlin-stdlib-js-ir'] === 'undefined') {
+      throw new Error("Error loading module 'Kermit-kermit-js-ir'. Its dependency 'kotlin-kotlin-stdlib-js-ir' was not found. Please, check whether 'kotlin-kotlin-stdlib-js-ir' is loaded prior to 'Kermit-kermit-js-ir'.");
+    }
+    root['Kermit-kermit-js-ir'] = factory(typeof this['Kermit-kermit-js-ir'] === 'undefined' ? {} : this['Kermit-kermit-js-ir'], this['kotlin-kotlin-stdlib-js-ir']);
+  }
+}(this, function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var classMeta = kotlin_kotlin.$_$.h5;
+  var objectMeta = kotlin_kotlin.$_$.h6;
+  var listOf = kotlin_kotlin.$_$.g4;
+  var interfaceMeta = kotlin_kotlin.$_$.o5;
+  var Unit_getInstance = kotlin_kotlin.$_$.o2;
+  var Enum = kotlin_kotlin.$_$.q7;
+  var stackTraceToString = kotlin_kotlin.$_$.l8;
+  //endregion
+  //region block: pre-declaration
+  Companion.prototype = Object.create(Logger.prototype);
+  Companion.prototype.constructor = Companion;
+  Severity.prototype = Object.create(Enum.prototype);
+  Severity.prototype.constructor = Severity;
+  ConsoleWriter.prototype = Object.create(LogWriter.prototype);
+  ConsoleWriter.prototype.constructor = ConsoleWriter;
+  //endregion
+  function LogWriter() {
+  }
+  LogWriter.prototype.h1a = function (severity) {
+    return true;
+  };
+  LogWriter.$metadata$ = classMeta('LogWriter');
+  function get_DEFAULT_MIN_SEVERITY() {
+    init_properties_Logger_kt_sgvsqe();
+    return DEFAULT_MIN_SEVERITY;
+  }
+  var DEFAULT_MIN_SEVERITY;
+  function get_DEFAULT_TAG() {
+    return DEFAULT_TAG;
+  }
+  var DEFAULT_TAG;
+  function Logger_init_$Init$(config, tag, $mask0, $marker, $this) {
+    if (!(($mask0 & 2) === 0))
+      tag = 'Kermit';
+    Logger.call($this, config, tag);
+    return $this;
+  }
+  function Companion() {
+    Companion_instance = this;
+    var tmp = LoggerGlobal_getInstance().j1a_1;
+    Logger_init_$Init$(tmp, null, 2, null, this);
+  }
+  Companion.prototype.m1a = function () {
+    return get_defaultTag();
+  };
+  Companion.prototype.n1a = function (tag) {
+    set_defaultTag(tag);
+  };
+  Companion.$metadata$ = objectMeta('Companion', undefined, undefined, undefined, undefined, Logger.prototype);
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Logger(config, tag) {
+    Companion_getInstance();
+    this.o1a_1 = config;
+    this.p1a_1 = tag;
+  }
+  Logger.prototype.q1a = function () {
+    return this.o1a_1;
+  };
+  Logger.prototype.m1a = function () {
+    return this.p1a_1;
+  };
+  Logger.prototype.r1a = function (tag) {
+    return new Logger(this.o1a_1, tag);
+  };
+  Logger.prototype.s1a = function (message) {
+    if (this.o1a_1.w1a().q3(Severity_Info_getInstance()) <= 0)
+      this.v1a(Severity_Info_getInstance(), this.m1a(), null, message());
+  };
+  Logger.prototype.t1a = function (message) {
+    if (this.o1a_1.w1a().q3(Severity_Error_getInstance()) <= 0)
+      this.v1a(Severity_Error_getInstance(), this.m1a(), null, message());
+  };
+  Logger.prototype.u1a = function (message) {
+    if (this.o1a_1.w1a().q3(Severity_Error_getInstance()) <= 0)
+      this.v1a(Severity_Error_getInstance(), this.m1a(), null, message);
+  };
+  Logger.prototype.v1a = function (severity, tag, throwable, message) {
+    {
+      {
+        var tmp0_forEach = this.o1a_1.x1a();
+        var tmp0_iterator = tmp0_forEach.g();
+        while (tmp0_iterator.h()) {
+          var element = tmp0_iterator.i();
+          {
+            if (element.h1a(severity)) {
+              {
+                element.i1a(severity, message, tag, throwable);
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  Logger.$metadata$ = classMeta('Logger');
+  function LoggerGlobal() {
+    LoggerGlobal_instance = this;
+    this.j1a_1 = mutableKermitConfigInit(listOf(platformLogWriter()));
+  }
+  LoggerGlobal.$metadata$ = objectMeta('LoggerGlobal');
+  var LoggerGlobal_instance;
+  function LoggerGlobal_getInstance() {
+    if (LoggerGlobal_instance == null)
+      new LoggerGlobal();
+    return LoggerGlobal_instance;
+  }
+  var properties_initialized_Logger_kt_6n8a9a;
+  function init_properties_Logger_kt_sgvsqe() {
+    if (properties_initialized_Logger_kt_6n8a9a) {
+    } else {
+      properties_initialized_Logger_kt_6n8a9a = true;
+      DEFAULT_MIN_SEVERITY = Severity_Verbose_getInstance();
+    }
+  }
+  function LoggerConfig() {
+  }
+  LoggerConfig.$metadata$ = interfaceMeta('LoggerConfig');
+  function MutableLoggerConfig() {
+  }
+  MutableLoggerConfig.$metadata$ = interfaceMeta('MutableLoggerConfig', [LoggerConfig]);
+  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_getInstance();
+    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);
+  }
+  Severity.$metadata$ = classMeta('Severity', undefined, undefined, undefined, undefined, Enum.prototype);
+  function Severity_Verbose_getInstance() {
+    Severity_initEntries();
+    return Severity_Verbose_instance;
+  }
+  function Severity_Debug_getInstance() {
+    Severity_initEntries();
+    return Severity_Debug_instance;
+  }
+  function Severity_Info_getInstance() {
+    Severity_initEntries();
+    return Severity_Info_instance;
+  }
+  function Severity_Error_getInstance() {
+    Severity_initEntries();
+    return Severity_Error_instance;
+  }
+  function ConsoleWriter() {
+    LogWriter.call(this);
+  }
+  ConsoleWriter.prototype.i1a = function (severity, message, tag, throwable) {
+    var output = '[' + tag + '] ' + message;
+    var tmp0_safe_receiver = throwable;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      var tmp$ret$0;
+      {
+        {
+        }
+        output = output + (' ' + stackTraceToString(tmp0_safe_receiver));
+        tmp$ret$0 = Unit_getInstance();
+      }
+    }
+    var tmp1_subject = severity;
+    var tmp0 = tmp1_subject.ue();
+    switch (tmp0) {
+      case 5:
+      case 4:
+        console.error(output);
+        break;
+      case 3:
+        console.warn(output);
+        break;
+      case 2:
+        console.info(output);
+        break;
+      case 1:
+      case 0:
+        console.log(output);
+        break;
+    }
+  };
+  ConsoleWriter.$metadata$ = classMeta('ConsoleWriter', undefined, undefined, undefined, undefined, LogWriter.prototype);
+  function JsMutableLoggerConfig(logWriters) {
+    this.y1a_1 = get_DEFAULT_MIN_SEVERITY();
+    this.z1a_1 = logWriters;
+  }
+  JsMutableLoggerConfig.prototype.w1a = function () {
+    return this.y1a_1;
+  };
+  JsMutableLoggerConfig.prototype.x1a = function () {
+    return this.z1a_1;
+  };
+  JsMutableLoggerConfig.$metadata$ = classMeta('JsMutableLoggerConfig', [MutableLoggerConfig]);
+  function set_defaultTag(_set____db54di) {
+    init_properties_KermitConfig_kt_vkjurc();
+    defaultTag = _set____db54di;
+  }
+  function get_defaultTag() {
+    init_properties_KermitConfig_kt_vkjurc();
+    return defaultTag;
+  }
+  var defaultTag;
+  function mutableKermitConfigInit(logWriters) {
+    init_properties_KermitConfig_kt_vkjurc();
+    return new JsMutableLoggerConfig(logWriters);
+  }
+  var properties_initialized_KermitConfig_kt_gdrujo;
+  function init_properties_KermitConfig_kt_vkjurc() {
+    if (properties_initialized_KermitConfig_kt_gdrujo) {
+    } else {
+      properties_initialized_KermitConfig_kt_gdrujo = true;
+      defaultTag = get_DEFAULT_TAG();
+    }
+  }
+  function platformLogWriter() {
+    return new ConsoleWriter();
+  }
+  //region block: init
+  DEFAULT_TAG = 'Kermit';
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Severity_Debug_getInstance;
+  _.$_$.b = Severity_Error_getInstance;
+  _.$_$.c = Severity_Info_getInstance;
+  _.$_$.d = Companion_getInstance;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=Kermit-kermit-js-ir.js.map

package/dist/kotlin/Kermit-kermit-js-ir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../LogWriter.kt","../../../../../Logger.kt","../../../../../commonMainSources/libraries/stdlib/common/src/generated/_Collections.kt","../../../../../ConsoleWriter.kt","../../../../../commonMainSources/libraries/stdlib/src/kotlin/util/Standard.kt","../../../../../JsMutableLoggerConfig.kt","../../../../../KermitConfig.kt","../../../../../platformLogWriter.kt"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB2D,OAAJ,I;;;;;IC4L9C,2B;;;;IACM,kB;;;;QA7LV,qB;MAAA,MAEuB,Q;IAFvB,+B;;;;;cA6JsC,gC;IAApB,4C;;;IAEO,OAAV,gB;;;IAmBR,eAAa,GAAb,C;;;;;;;;;;IAnLZ,uB;IAEI,mB;IACA,gB;;;IADA,iB;;;IACK,iB;;;IAGD,OAAO,WAAO,IAAK,MAAZ,EAAoB,GAApB,C;;;QA8CH,UAAO,MAAP,qC;MACA,sCAAmB,UAAnB,EAAwB,IAAxB,EAA8B,SAA9B,C;;;QAqCA,UAAO,MAAP,sC;MACA,uCAAoB,UAApB,EAAyB,IAAzB,EAA+B,SAA/B,C;;;QASA,UAAO,MAAP,sC;MACA,uCAAoB,UAApB,EAAyB,IAAzB,EAA+B,OAA/B,C;;;;;QCkEgB,mBAjBe,IAiBtB,MAAO,M;QAooDR,oC;eAAA,iB;UAAX,cAAW,iB;;gBDzmDq6rD,OA3Ct6rD,KAjBP,QAiBO,C;;gBA2Cs6rD,OAvD76rD,KAAI,QAAJ,EAFA,OAEA,EAJA,GAIA,EAHA,SAGA,C;;;;;;;;;;;IA8CY,qCAAwB,OAAO,mBAAP,CAAxB,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IEvLF,oB;;;IAEd,aAAc,GAAd,GAAgB,GAAhB,GAAmB,IAAnB,GAAsB,O;IACtB,kC;QAAA,kBAAW,Q;MAAA,I;;;;;;QCMkC,mBAAW,GAAX,GAAiB,mBAA9C,kBAA8C,CAAjB,C;QAqFjD,8B;;;IDxFU,2B;IAAA,4B;;WACO,C;WAAiB,C;QAAS,OAAQ,OAAM,MAAN,C;;WAClC,C;QAAQ,OAAQ,MAAK,MAAL,C;;WAChB,C;QAAQ,OAAQ,MAAK,MAAL,C;;WAChB,C;WAAgB,C;QAAW,OAAQ,KAAI,MAAJ,C;;;;;;IEdf,uC;IACS,uB;;;IADrC,iB;;;IACA,iB;;;;;ICAG,2B;;;;IAAA,iB;;;;;IAFiH,OAAjC,0BAAsB,UAAtB,C;;;;;;;mBAEvD,iB;;;;ICFkB,OAAf,mB;;;gBNiMX,Q;;;;;;;;;;;"}