kailogger 1.0.1-dark.red → 1.0.2

package/examples/demo.js

@@ -0,0 +1,134 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var src_1 = require("../src");
+var path = require("path");
+function runDemo() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.clear();
+                    src_1.kai.setSoundsDir(path.join(__dirname, '../src/sounds'));
+                    src_1.kai.box('KaiLogger v1.0.1', 'Now with Charts, Notifications, Screenshots & More!');
+                    console.log('\n');
+                    src_1.kai.info('📋 Basic Logging');
+                    src_1.kai.success('Operation completed');
+                    src_1.kai.warning('Low memory');
+                    src_1.kai.error('Connection failed');
+                    console.log('\n');
+                    src_1.kai.info('📊 Charts Demo');
+                    src_1.kai.chart([
+                        { label: 'Users', value: 1500 },
+                        { label: 'Sales', value: 890 },
+                        { label: 'Orders', value: 450 },
+                        { label: 'Returns', value: 32 }
+                    ]);
+                    // Sparkline
+                    src_1.kai.info('📈 Sparkline (CPU usage over time)');
+                    src_1.kai.sparkline([10, 25, 30, 15, 45, 60, 55, 70, 85, 60, 40, 30]);
+                    // Gauge
+                    console.log('');
+                    src_1.kai.gauge(75, 100, 'Memory');
+                    src_1.kai.gauge(45, 100, 'CPU');
+                    src_1.kai.gauge(95, 100, 'Disk');
+                    // ===== ENCRYPTION =====
+                    console.log('\n');
+                    src_1.kai.info('🔐 Encryption Demo');
+                    src_1.kai.masked('API Key', 'sk-1234567890abcdef', 4);
+                    src_1.kai.masked('Password', 'superSecretPassword123', 3);
+                    src_1.kai.encrypted('This is a secret message!', 'my-secret-key');
+                    // ===== TREE =====
+                    console.log('\n');
+                    src_1.kai.info('🌳 Tree View');
+                    src_1.kai.tree({
+                        src: {
+                            core: { 'Logger.ts': null },
+                            features: { 'Chart.ts': null, 'Sound.ts': null },
+                            sounds: { 'success.wav': null, 'error.wav': null }
+                        },
+                        'package.json': null
+                    });
+                    // ===== TABLE =====
+                    console.log('\n');
+                    src_1.kai.info('📉 Table');
+                    src_1.kai.table([
+                        { name: 'Kai', role: 'Admin', status: '🟢' },
+                        { name: 'Neo', role: 'User', status: '🟡' },
+                        { name: 'Trinity', role: 'Mod', status: '🔴' }
+                    ]);
+                    // ===== SOUNDS =====
+                    console.log('\n');
+                    src_1.kai.info('🔊 Sound Demo');
+                    src_1.kai.info('Playing success sound...');
+                    return [4 /*yield*/, src_1.kai.soundSuccess()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
+                case 2:
+                    _a.sent();
+                    src_1.kai.warning('Playing warning sound...');
+                    return [4 /*yield*/, src_1.kai.soundWarning()];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
+                case 4:
+                    _a.sent();
+                    src_1.kai.error('Playing error sound...');
+                    return [4 /*yield*/, src_1.kai.soundError()];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
+                case 6:
+                    _a.sent();
+                    // ===== NOTIFICATION =====
+                    console.log('\n');
+                    src_1.kai.info('💬 Sending Desktop Notification...');
+                    src_1.kai.notify('KaiLogger demo finished!', '✅ Success');
+                    return [4 /*yield*/, src_1.kai.soundNotification()];
+                case 7:
+                    _a.sent();
+                    // ===== DONE =====
+                    console.log('\n');
+                    src_1.kai.success('✨ Demo complete! KaiLogger v2.1.0 is ready.');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+runDemo();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kailogger",
-  "version": "1.0.1-dark.red",
+  "version": "1.0.2",
   "description": "",
   "repository": {
     "type": "git",
@@ -13,11 +13,11 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/copy-assets.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [],
-  "author": "",
+  "author": "Soblend Development",
   "license": "ISC",
   "devDependencies": {
     "@types/crypto-js": "^4.2.2",
@@ -28,13 +28,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "chalk": "^4.1.2",
-    "cli-highlight": "^2.1.11",
     "crypto-js": "^4.2.0",
-    "gradient-string": "^3.0.0",
     "node-notifier": "^10.0.1",
-    "play-sound": "^1.1.6",
-    "stack-trace": "^1.0.0-pre2",
-    "syntax-error": "^1.4.0"
+    "stack-trace": "^1.0.0-pre2"
   }
 }

package/scripts/copy-assets.js

@@ -0,0 +1,37 @@
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.resolve(__dirname, '..');
+const srcDir = path.join(rootDir, 'src');
+const distDir = path.join(rootDir, 'dist');
+
+console.log('📦 Copying assets...');
+
+// Copy sounds
+const soundsSrc = path.join(srcDir, 'sounds');
+const soundsDist = path.join(distDir, 'sounds');
+
+if (fs.existsSync(soundsSrc)) {
+    if (!fs.existsSync(soundsDist)) fs.mkdirSync(soundsDist, { recursive: true });
+    fs.readdirSync(soundsSrc).forEach(file => {
+        if (file.endsWith('.wav') || file.endsWith('.mp3')) {
+            fs.copyFileSync(path.join(soundsSrc, file), path.join(soundsDist, file));
+        }
+    });
+    console.log('  ✔ Sounds copied');
+}
+
+// Copy icon
+const iconSrc = path.join(srcDir, 'icon');
+const iconDist = path.join(distDir, 'icon');
+
+if (fs.existsSync(iconSrc)) {
+    if (!fs.existsSync(iconDist)) fs.mkdirSync(iconDist, { recursive: true });
+    fs.readdirSync(iconSrc).forEach(file => {
+        fs.copyFileSync(path.join(iconSrc, file), path.join(iconDist, file));
+    });
+    console.log('  ✔ Icon copied');
+}
+
+console.log('✨ Build assets complete');

package/src/core/Logger.ts

@@ -1,6 +1,7 @@
-import chalk from 'chalk';
+
 import * as fs from 'fs';
-import { paint } from '../styles/gradients';
+import { paint, palettes, ThemeName } from '../styles/palettes';
+import { KaiChroma } from '../styles/KaiChroma';
 import { KaiSpinner } from '../utils/spinner';
 import { KaiProgress } from '../utils/progress';
 import { KaiTable } from '../utils/table';
@@ -9,7 +10,6 @@ import { KaiSelection } from '../utils/selection';
 import { KaiJson } from '../utils/json';
 import { PrettyError } from '../utils/prettyError';
 import { stripAnsi } from '../utils/stripAnsi';
-import { ThemeName, palettes } from '../styles/palettes';
 import { config } from './Config';
 import { ScopedLogger } from './Scope';
 import { KaiTimer } from '../features/Timer';
@@ -31,16 +31,19 @@ interface LoggerOptions {
     silent?: boolean;
     timestamp?: 'ISO' | 'locale' | 'relative' | 'none';
 }
+
 export class KaiLogger {
     private spinner = new KaiSpinner();
     private timer = new KaiTimer();
     private logFilePath?: string;
     private buffer: string[] = [];
     private startTime: number = Date.now();
+
     public theme: ThemeName;
     public level: LogLevel;
     public silent: boolean;
     public timestampFormat: 'ISO' | 'locale' | 'relative' | 'none';
+
     constructor(options: LoggerOptions | ThemeName = 'zen') {
         if (typeof options === 'string') {
             this.theme = options;
@@ -56,6 +59,9 @@ export class KaiLogger {
         }
         paint.setTheme(this.theme);
     }
+
+    // ========== CONFIGURATION ==========
+    
     public configure(options: Partial<LoggerOptions>): void {
         if (options.theme) this.setTheme(options.theme);
         if (options.level) this.level = options.level;
@@ -63,31 +69,47 @@ export class KaiLogger {
         if (options.silent !== undefined) this.silent = options.silent;
         if (options.timestamp) this.timestampFormat = options.timestamp;
     }
+
     public setTheme(theme: ThemeName): void {
         this.theme = theme;
         paint.setTheme(theme);
     }
+
     public setLevel(level: LogLevel): void {
         this.level = level;
     }
+
     public setSilent(silent: boolean): void {
         this.silent = silent;
     }
+
+    // ========== TRANSPORTS ==========
+
     public addFileTransport(options: FileTransportOptions): void {
         config.addTransport(new FileTransport(options));
     }
+
     public addWebhookTransport(options: WebhookTransportOptions): void {
         config.addTransport(new WebhookTransport(options));
     }
+
     public removeTransport(name: string): void {
         config.removeTransport(name);
     }
+
+    // ========== SCOPED LOGGERS ==========
+
     public scope(name: string): ScopedLogger {
         return new ScopedLogger(this, name);
     }
+
+    // ========== TIMESTAMPS ==========
+
     private getTime(): string {
         if (this.timestampFormat === 'none') return '';
+        
         const now = new Date();
+        
         switch (this.timestampFormat) {
             case 'ISO':
                 return `[${now.toISOString()}]`;
@@ -100,238 +122,333 @@ export class KaiLogger {
                 return `[${now.toLocaleTimeString()}]`;
         }
     }
+
+    // ========== LEVEL CHECKING ==========
+
     private shouldLog(level: LogLevel): boolean {
         if (this.silent) return false;
         return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
     }
+
+    // ========== FILE & TRANSPORT LOGGING ==========
+
     private logToFile(level: string, message: string): void {
         if (this.logFilePath) {
             const cleanMsg = stripAnsi(message);
             const logLine = `${this.getTime()} [${level.toUpperCase()}] ${cleanMsg}\n`;
             fs.appendFileSync(this.logFilePath, logLine);
         }
+
         const transports = config.get('transports') || [];
         transports.forEach(t => t.log(level as LogLevel, message));
     }
+
     private addToBuffer(level: string, message: string): void {
         this.buffer.push(`${this.getTime()} [${level.toUpperCase()}] ${message}`);
     }
+
     public getBuffer(): string[] {
         return [...this.buffer];
     }
+
     public clearBuffer(): void {
         this.buffer = [];
     }
+
+    // ========== CORE LOGGING ==========
+
     private print(level: LogLevel, label: string, message: string, ...args: any[]): void {
         if (!this.shouldLog(level)) {
             this.addToBuffer(level, message);
             return;
         }
+
         this.stopSpinner();
-        const colors = (paint.text as any)[level] as string[];
-        const time = this.timestampFormat !== 'none' ? chalk.gray(this.getTime()) + ' ' : '';
+        // Accedemos safe a paint.colors[level]
+        const colors = (paint.colors as any)[level] as string[]; 
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
         const badge = paint.apply(` ${label.padEnd(7)} `, colors);
         const output = `${time}${badge} ${message}`;
+        
         console.log(output, ...args);
+        
         const fileMsg = [message, ...args.map(a => typeof a === 'object' ? JSON.stringify(a) : a)].join(' ');
         this.logToFile(level, fileMsg);
         this.addToBuffer(level, fileMsg);
     }
+
     public success(message: string, ...args: any[]): void {
         this.print('success', '✔ SUCCESS', message, ...args);
     }
+
     public error(message: string | Error, ...args: any[]): void {
         if (!this.shouldLog('error')) return;
+        
         if (message instanceof Error) {
             this.stopSpinner();
-            PrettyError.handle(message, palettes[this.theme]);
+            PrettyError.handle(message, paint.colors);
             this.logToFile('error', message.toString());
             this.addToBuffer('error', message.toString());
         } else {
             this.print('error', '✖ ERROR', message, ...args);
         }
     }
+
     public warning(message: string, ...args: any[]): void {
         this.print('warning', '⚠ WARN', message, ...args);
     }
+
     public info(message: string, ...args: any[]): void {
         this.print('info', 'ℹ INFO', message, ...args);
     }
+
     public debug(message: string, ...args: any[]): void {
         this.print('debug', '⚙ DEBUG', message, ...args);
     }
+
     public log(message: string): void {
         if (this.silent) return;
         this.stopSpinner();
-        const time = this.timestampFormat !== 'none' ? chalk.gray(this.getTime()) + ' ' : '';
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
         console.log(`${time}${message}`);
         this.logToFile('log', message);
     }
+
+    // ========== CUSTOM BADGE ==========
+
     public custom(badge: string, color: string, message: string, ...args: any[]): void {
         if (this.silent) return;
         this.stopSpinner();
-        const time = this.timestampFormat !== 'none' ? chalk.gray(this.getTime()) + ' ' : '';
-        const styledBadge = chalk.bgHex(color).black(` ${badge.toUpperCase().padEnd(7)} `);
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
+        const styledBadge = KaiChroma.bgHex(color, ` ${badge.toUpperCase().padEnd(7)} `);
         console.log(`${time}${styledBadge} ${message}`, ...args);
         this.logToFile(badge, message);
     }
+
+    // ========== BOX ==========
+
     public box(title: string, message: string): void {
         if (this.silent) return;
         this.stopSpinner();
         const width = Math.max(message.length, title.length) + 4;
-        const border = paint.apply('─'.repeat(width), paint.text.info);
-        const topLeft = paint.apply('╭', paint.text.info);
-        const topRight = paint.apply('╮', paint.text.info);
-        const bottomLeft = paint.apply('╰', paint.text.info);
-        const bottomRight = paint.apply('╯', paint.text.info);
-        const side = paint.apply('│', paint.text.info);
+        const border = paint.apply('─'.repeat(width), paint.colors.info);
+        const topLeft = paint.apply('╭', paint.colors.info);
+        const topRight = paint.apply('╮', paint.colors.info);
+        const bottomLeft = paint.apply('╰', paint.colors.info);
+        const bottomRight = paint.apply('╯', paint.colors.info);
+        const side = paint.apply('│', paint.colors.info);
+
         console.log(`${topLeft}${border}${topRight}`);
-        console.log(`${side} ${paint.apply(title.padEnd(width - 2), paint.text.success)} ${side}`);
-        console.log(`${side}${paint.apply('─'.repeat(width), paint.text.debug)}${side}`);
+        console.log(`${side} ${paint.apply(title.padEnd(width - 2), paint.colors.success)} ${side}`);
+        console.log(`${side}${paint.apply('─'.repeat(width), paint.colors.debug)}${side}`);
         console.log(`${side} ${message.padEnd(width - 2)} ${side}`);
         console.log(`${bottomLeft}${border}${bottomRight}`);
+        
         this.logToFile('box', `${title}: ${message}`);
     }
+
+    // ========== SPINNER ==========
+
     public await(message: string): void {
         if (this.silent) return;
-        this.spinner.start(message, paint.text.info[0]);
+        this.spinner.start(message, paint.colors.info[0]);
     }
+
     public stop(message?: string): void {
-        this.spinner.stop('✔', message, paint.text.success[1]);
+        this.spinner.stop('✔', message, paint.colors.success[1]);
         if (message) this.logToFile('stop', message);
     }
+
     private stopSpinner(): void {
+        this.spinner.stop();
     }
+
+    // ========== PROGRESS ==========
+
     public createProgress(total: number, width?: number): KaiProgress {
         return new KaiProgress(total, width, this.theme);
     }
+
+    // ========== TABLE ==========
+
     public table(data: any[]): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiTable.print(data, palettes[this.theme]);
+        KaiTable.print(data, paint.colors);
         this.logToFile('table', JSON.stringify(data));
     }
+
+    // ========== JSON ==========
+
     public json(data: any): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiJson.print(data, palettes[this.theme]);
+        KaiJson.print(data, paint.colors);
         this.logToFile('json', JSON.stringify(data));
     }
+
+    // ========== TREE ==========
+
     public tree(data: any): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiTree.print(data, palettes[this.theme]);
+        KaiTree.print(data, paint.colors);
         this.logToFile('tree', JSON.stringify(data));
     }
+
+    // ========== DIFF ==========
+
     public diff(before: any, after: any): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiDiff.print(before, after, palettes[this.theme]);
+        KaiDiff.print(before, after, paint.colors);
         this.logToFile('diff', JSON.stringify({ before, after }));
     }
+
+    // ========== TIMER ==========
+
     public time(label: string): void {
         this.timer.time(label);
     }
+
     public timeEnd(label: string): number | null {
         if (this.silent) return null;
-        return this.timer.timeEnd(label, palettes[this.theme]);
+        return this.timer.timeEnd(label, paint.colors);
     }
+
+    // ========== PROMPTS ==========
+
     public async ask(question: string): Promise<string> {
         this.stopSpinner();
-        const answer = await KaiPrompt.ask(question, palettes[this.theme]);
+        // Pasamos theme.info colors, asumimos que prompt maneja esto
+        const answer = await KaiPrompt.ask(question, paint.colors);
         this.logToFile('ask', `${question} -> ${answer}`);
         return answer;
     }
+
     public async confirm(question: string): Promise<boolean> {
         this.stopSpinner();
-        const answer = await KaiPrompt.confirm(question, palettes[this.theme]);
+        const answer = await KaiPrompt.confirm(question, paint.colors);
         this.logToFile('confirm', `${question} -> ${answer}`);
         return answer;
     }
+
     public async select(question: string, options: string[]): Promise<string> {
         this.stopSpinner();
-        const answer = await KaiSelection.select(question, options, palettes[this.theme]);
+        const answer = await KaiSelection.select(question, options, paint.colors);
         this.logToFile('select', `${question} -> ${answer}`);
         return answer;
     }
+
     public async multiselect(question: string, options: string[]): Promise<string[]> {
         this.stopSpinner();
-        const answer = await KaiSelection.multiselect(question, options, palettes[this.theme]);
+        const answer = await KaiSelection.multiselect(question, options, paint.colors);
         this.logToFile('multiselect', `${question} -> ${answer.join(', ')}`);
         return answer;
     }
+
+    // ========== CHARTS ==========
+
     public chart(data: { label: string; value: number }[], options?: { width?: number; showValues?: boolean }): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiChart.bar(data, palettes[this.theme], options);
+        KaiChart.bar(data, paint.colors, options);
     }
+
     public sparkline(values: number[]): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiChart.sparkline(values, palettes[this.theme]);
+        KaiChart.sparkline(values, paint.colors);
     }
+
     public gauge(value: number, max: number, label?: string): void {
         if (this.silent) return;
         this.stopSpinner();
-        KaiChart.gauge(value, max, palettes[this.theme], label);
+        KaiChart.gauge(value, max, paint.colors, label);
     }
+
+    // ========== NOTIFICATIONS ==========
+
     public notify(message: string, title?: string): void {
         KaiNotify.send({ message, title });
     }
+
     public notifySuccess(message: string): void {
         KaiNotify.success(message);
     }
+
     public notifyError(message: string): void {
         KaiNotify.error(message);
     }
+
+    // ========== SCREENSHOT ==========
+
     public startCapture(): void {
         KaiScreenshot.startCapture();
     }
+
     public stopCapture(): string[] {
         return KaiScreenshot.stopCapture();
     }
+
     public saveScreenshot(filename: string): void {
         KaiScreenshot.save(filename);
     }
+
     public saveScreenshotHtml(filename: string): void {
         KaiScreenshot.saveHtml(filename);
     }
+
+    // ========== ENCRYPTION ==========
+
     public setEncryptionKey(key: string): void {
         KaiEncrypt.setDefaultKey(key);
     }
+
     public encrypted(message: string, key?: string): void {
         if (this.silent) return;
         this.stopSpinner();
         KaiEncrypt.printEncrypted(message, key);
     }
+
     public decrypted(encryptedMessage: string, key?: string): void {
         if (this.silent) return;
         this.stopSpinner();
         KaiEncrypt.printDecrypted(encryptedMessage, key);
     }
+
     public masked(label: string, value: string, showLast?: number): void {
         if (this.silent) return;
         this.stopSpinner();
         KaiEncrypt.printMasked(label, value, showLast);
     }
+
+    // ========== SOUNDS ==========
+
     public setSoundsDir(dir: string): void {
         KaiSound.setSoundsDir(dir);
     }
+
     public beep(): void {
         KaiSound.beep();
     }
+
     public async soundSuccess(): Promise<void> {
         await KaiSound.success();
     }
+
     public async soundError(): Promise<void> {
         await KaiSound.error();
     }
+
     public async soundWarning(): Promise<void> {
         await KaiSound.warning();
     }
+
     public async soundNotification(): Promise<void> {
         await KaiSound.notification();
     }
+
     public async playSound(filename: string): Promise<void> {
         await KaiSound.play(filename);
     }