@duckbug/js 0.1.0 → 0.1.2

package/README.md

@@ -1,30 +1,47 @@
-# Rsbuild project
+# @duckbug/js
 
-## Setup
+[![npm version](https://badge.fury.io/js/@duckbug%2Fjs.svg)](https://www.npmjs.com/package/@duckbug/js)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Install the dependencies:
+The official JavaScript SDK for [DuckBug.io](https://duckbug.io) - a flexible logging and error tracking platform.
 
-```bash
-yarn install
-```
+## Features
 
-Build lib:
+- 🦆 **Simple Integration**: Easy setup with DuckBug.io
+- 🔌 **Provider Architecture**: Extensible plugin system for custom logging providers
+- 📊 **Multiple Log Levels**: Support for debug, info, warn, and error levels
+- 🎯 **TypeScript Support**: Full TypeScript support with type definitions
+- 📦 **Dual Module Format**: Both CommonJS and ES Module support
+- ⚡ **Lightweight**: Minimal dependencies and small bundle size
+
+## Installation
 
 ```bash
-yarn compile
+# npm
+npm install @duckbug/js
+
+# yarn
+yarn add @duckbug/js
+
+# pnpm
+pnpm add @duckbug/js
 ```
 
+## Quick Start
+
+### Basic Usage
 
-##  Example
+```typescript
+import { DuckSDK, DuckBugProvider } from '@duckbug/js';
 
-### Basic usage
-```ts
+// Initialize with DuckBug.io provider
 const providers = [
-  new DuckBugPlugin({
-    dsn: "123456",
+  new DuckBugProvider({
+    dsn: 'your-duckbug-dsn-here'
   })
-]
+];
 
+// Create SDK instance with optional configuration
 const duck = new DuckSDK(providers, {
   logReports: {
     log: false,
@@ -33,33 +50,181 @@ const duck = new DuckSDK(providers, {
   }
 });
 
-duck.log('Info message', { message: 'All good' })
-duck.debug('Debug message', { message: 'All fine' })
-duck.warn('Warn message', { message: 'So so' })
-duck.error('Error message', { message: 'Ay, Caramba!' })
+// Start logging
+duck.log('Info message', { userId: 123, action: 'user_login' });
+duck.debug('Debug message', { debugInfo: 'Connection established' });
+duck.warn('Warning message', { warning: 'Rate limit approaching' });
+duck.error('Error message', { error: 'Database connection failed' });
+duck.fatal('Fatal message', { error: 'Ay, caramba' });
+
+//Send error
+const testError = new Error("Integration test error");
+testError.stack =
+  "Error: Integration test error\n    at integration.test.ts:1:1";
+
+// Use quack method directly on provider
+duckBugProvider.quack("INTEGRATION_ERROR", testError);
 ```
 
-### Create own plugin
-```ts
-class TelegramProvider extends Providers {
+## API Reference
+
+### DuckSDK
+
+The main SDK class that manages logging across multiple providers.
+
+#### Constructor
+
+```typescript
+new DuckSDK(providers: Provider[], config?: LogProviderConfig)
+```
+
+- `providers`: Array of provider instances
+- `config`: Optional configuration for log reporting levels
+
+#### Methods
+
+- `log(tag: string, payload?: object)`: Log an info-level message
+- `debug(tag: string, payload?: object)`: Log a debug-level message
+- `warn(tag: string, payload?: object)`: Log a warning-level message
+- `error(tag: string, payload?: object)`: Log an error-level message
+- `fatal(tag: string, payload?: object)`: Log an fatal-level message
+- `quack(tag: string, error: Error)`: Report error
+
+### DuckBugProvider
+
+The official DuckBug.io provider for sending logs to the DuckBug.io platform.
+
+#### Constructor
+
+```typescript
+new DuckBugProvider(config: DuckConfig)
+```
+
+- `config.dsn`: Your DuckBug.io DSN (Data Source Name)
+
+### Log Provider Configuration
+
+```typescript
+type LogProviderConfig = {
+  logReports: {
+    log?: boolean;    // Enable/disable info logs (default: false)
+    warn?: boolean;   // Enable/disable warning logs (default: true)
+    error?: boolean;  // Enable/disable error logs (default: true)
+  }
+}
+```
+
+## Custom Providers
+
+You can create custom providers by implementing the `Provider` interface:
+
+```typescript
+import { Provider, LogLevel } from '@duckbug/js';
+
+class TelegramProvider implements Provider {
+  constructor(private botToken: string, private chatId: string) {}
+
   log(...args: unknown[]): void {
-    //send to telegram log
+    this.sendToTelegram('📝', args);
   }
+
   warn(...args: unknown[]): void {
-    //send to telegram warn
+    this.sendToTelegram('⚠️', args);
   }
+
   error(...args: unknown[]): void {
-    //send to telegram error
+    this.sendToTelegram('🚨', args);
+  }
+
+  report(tag: string, level: LogLevel, payload?: object): void {
+    const emojiMap: Record<LogLevel, string> = {
+      INFO: '📝',
+      DEBUG: '🦆',
+      WARN: '⚠️',
+      ERROR: '🚨',
+      FATAL: '💀',
+    };
+    this.sendToTelegram(emojiMap[level], [tag, payload]);
+  }
+
+  quack(tag: string, error: Error): void {
+    this.sendToTelegram('💀', [tag, error.message]);
+  }
+
+  private sendToTelegram(emoji: string, args: unknown[]) {
+    const message = `${emoji} ${args.join(' ')}`;
+    // Implementation to send message to Telegram
+    fetch(`https://api.telegram.org/bot${this.botToken}/sendMessage`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: this.chatId,
+        text: message
+      })
+    });
   }
 }
 
+// Usage
 const providers = [
-  new DuckBugProvider({
-    dsn: "123456",
-  }),
+  new DuckBugProvider({ dsn: 'your-dsn' }),
+  new TelegramProvider('your-bot-token', 'your-chat-id')
+];
+
+const duck = new DuckSDK(providers);
+```
+
+## Development
+
+### Setup
+
+Install dependencies:
+
+```bash
+yarn install
+```
+
+### Build
+
+Build the library:
 
-  new TelegramProvider()
-]
+```bash
+yarn build
+```
+
+### Linting
+
+Run linting:
+
+```bash
+yarn lint
+```
+
+## TypeScript Support
+
+This package includes TypeScript definitions. All exports are fully typed:
 
-new DuckSDK(providers);
+```typescript
+import type { Provider, DuckConfig, LogLevel } from '@duckbug/js';
 ```
+
+## Browser Compatibility
+
+This SDK works in all modern browsers that support:
+- ES2015+ (ES6)
+- Fetch API
+- JSON API
+
+For older browsers, you may need to include polyfills.
+
+## License
+
+MIT © [DuckBug.io](https://duckbug.io)
+
+## Support
+
+- 🐛 Issues: [GitHub Issues](https://github.com/duckbugio/duckbug-js/issues)
+
+---
+
+**Made with 🦆 by the DuckBug.io team**

package/dist/cjs/DuckBug/DuckBugConfig.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/DuckBugProvider.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DuckBugProvider: ()=>DuckBugProvider
+});
+const index_cjs_namespaceObject = require("../SDK/index.cjs");
+const external_DuckBugService_cjs_namespaceObject = require("./DuckBugService.cjs");
+class DuckBugProvider {
+    service;
+    constructor(config){
+        this.service = new external_DuckBugService_cjs_namespaceObject.DuckBugService(config);
+    }
+    warn(...args) {
+        this.service.sendLog({
+            time: this.getTimeStamp(),
+            level: index_cjs_namespaceObject.logLevel.WARN,
+            message: this.convertArgsToString(args[0]),
+            context: this.convertArgsToString(args.slice(1))
+        });
+    }
+    error(...args) {
+        this.service.sendLog({
+            time: this.getTimeStamp(),
+            level: index_cjs_namespaceObject.logLevel.ERROR,
+            message: this.convertArgsToString(args[0]),
+            context: this.convertArgsToString(args.slice(1))
+        });
+    }
+    log(...args) {
+        this.service.sendLog({
+            time: this.getTimeStamp(),
+            level: index_cjs_namespaceObject.logLevel.INFO,
+            message: this.convertArgsToString(args[0]),
+            context: this.convertArgsToString(args.slice(1))
+        });
+    }
+    report(tag, level, payload) {
+        this.service.sendLog({
+            time: this.getTimeStamp(),
+            level,
+            message: tag,
+            context: JSON.stringify(payload)
+        });
+    }
+    quack(tag, error) {
+        this.service.sendError({
+            stack: error.stack,
+            message: tag,
+            context: error.message
+        });
+    }
+    convertArgsToString(...args) {
+        return args.map((arg)=>"object" == typeof arg ? JSON.stringify(arg) : String(arg)).join(" ");
+    }
+    getTimeStamp() {
+        return Date.now();
+    }
+}
+exports.DuckBugProvider = __webpack_exports__.DuckBugProvider;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DuckBugProvider"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/DuckBugService.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DuckBugService: ()=>DuckBugService
+});
+class DuckBugService {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    sendLog(logInfo) {
+        fetch(`${this.config.dsn}/logs`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(logInfo)
+        });
+    }
+    sendError(errorInfo) {
+        fetch(`${this.config.dsn}/errors`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(errorInfo)
+        });
+    }
+}
+exports.DuckBugService = __webpack_exports__.DuckBugService;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DuckBugService"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/Log.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DuckBugProvider: ()=>external_DuckBugProvider_cjs_namespaceObject.DuckBugProvider
+});
+const external_DuckBugProvider_cjs_namespaceObject = require("./DuckBugProvider.cjs");
+exports.DuckBugProvider = __webpack_exports__.DuckBugProvider;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DuckBugProvider"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/SDK/DuckSDK.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DuckSDK: ()=>DuckSDK
+});
+const external_index_cjs_namespaceObject = require("./index.cjs");
+class DuckSDK {
+    providers;
+    constructor(providers, logProviderConfig){
+        this.providers = providers;
+        new external_index_cjs_namespaceObject.LogProvider(providers, logProviderConfig);
+    }
+    log(tag, payload) {
+        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+    }
+    error(tag, payload) {
+        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+    }
+    debug(tag, payload) {
+        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+    }
+    warn(tag, payload) {
+        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.WARN, payload);
+    }
+    fatal(tag, payload) {
+        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.FATAL, payload);
+    }
+    quack() {}
+    sendReportToPlugins(tag, level, payload) {
+        this.providers.forEach((plugin)=>plugin.report(tag, level, payload));
+    }
+}
+exports.DuckSDK = __webpack_exports__.DuckSDK;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DuckSDK"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/SDK/LogLevel.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    logLevel: ()=>logLevel
+});
+const logLevel = {
+    DEBUG: "DEBUG",
+    INFO: "INFO",
+    WARN: "WARN",
+    ERROR: "ERROR",
+    FATAL: "FATAL"
+};
+exports.logLevel = __webpack_exports__.logLevel;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "logLevel"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/SDK/LogProvider.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LogProvider: ()=>LogProvider
+});
+class LogProvider {
+    originalConsole = {
+        log: console.log,
+        error: console.error,
+        warn: console.warn
+    };
+    providers;
+    logProviderConfig = {
+        logReports: {
+            log: false,
+            warn: true,
+            error: true
+        }
+    };
+    constructor(providers, logProviderConfig){
+        if (logProviderConfig) this.logProviderConfig = logProviderConfig;
+        this.providers = providers;
+        this.initialize();
+    }
+    initialize() {
+        if (this.logProviderConfig.logReports.log) this.overrideLog();
+        if (this.logProviderConfig.logReports.warn) this.overrideWarn();
+        if (this.logProviderConfig.logReports.error) this.overrideError();
+    }
+    overrideError() {
+        console.error = (...args)=>{
+            this.originalConsole.error.apply(console, args);
+            this.callPlugins((plugin)=>{
+                plugin.error(args);
+            });
+        };
+    }
+    overrideLog() {
+        console.log = (...args)=>{
+            this.originalConsole.log.apply(console, args);
+            this.callPlugins((plugin)=>{
+                plugin.log(args);
+            });
+        };
+    }
+    overrideWarn() {
+        console.warn = (...args)=>{
+            this.originalConsole.warn.apply(console, args);
+            this.callPlugins((plugin)=>{
+                plugin.warn(args);
+            });
+        };
+    }
+    callPlugins(callback) {
+        this.providers.forEach((plugin)=>{
+            callback(plugin);
+        });
+    }
+}
+exports.LogProvider = __webpack_exports__.LogProvider;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "LogProvider"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/SDK/LogProviderConfig.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});