@hamak/logging 0.5.1

package/README.md

@@ -0,0 +1,252 @@
+# Pluggable Logging System
+
+A comprehensive, pluggable logging system for the app-framework monorepo.
+
+## Packages
+
+- **`@hamak/logging-api`** - Public interfaces and types
+- **`@hamak/logging-spi`** - Service Provider Interfaces for extensions
+- **`@hamak/logging-impl`** - Core implementation
+
+## Quick Start
+
+```typescript
+import { createLoggingPlugin } from '@hamak/logging-impl';
+import { LogLevel } from '@hamak/logging-api';
+
+// Create logging plugin with default configuration
+const loggingPlugin = createLoggingPlugin();
+
+// Or with custom configuration
+const loggingPlugin = createLoggingPlugin({
+  globalLevel: LogLevel.DEBUG,
+  interceptConsole: true, // Default: true
+  devFormatter: true,      // Default: true in development
+  pluginLevels: {
+    'my-plugin': LogLevel.TRACE
+  }
+});
+
+// Use in microkernel
+const host = createHost({
+  plugins: [loggingPlugin, myPlugin]
+});
+```
+
+## Features
+
+### ✅ Context-Aware Logging
+
+```typescript
+export const myPlugin: PluginModule = {
+  initialize(ctx) {
+    const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+    const logger = logManager.createLogger({ plugin: 'my-plugin' });
+
+    logger.info('Plugin initializing');
+    // Output: ℹ️  INFO [my-plugin] Plugin initializing
+
+    const childLogger = logger.child({ module: 'auth' });
+    childLogger.warn('Authentication failed');
+    // Output: ⚠️  WARN [my-plugin] {auth} Authentication failed
+  }
+};
+```
+
+### ✅ Console Interception (Default: Enabled)
+
+**All `console.log/warn/error` calls automatically route through the logging system!**
+
+```typescript
+// With interception enabled (default)
+console.log('Hello world');
+// → Routes through logger.info('Hello world')
+
+console.warn('Warning message');
+// → Routes through logger.warn('Warning message')
+
+console.error('Error occurred', new Error('details'));
+// → Routes through logger.error('Error occurred', error)
+```
+
+**Disable if needed:**
+
+```typescript
+const loggingPlugin = createLoggingPlugin({
+  interceptConsole: false // Disable console interception
+});
+```
+
+### ✅ Performance Timing
+
+```typescript
+logger.time('database-query');
+await db.query('SELECT * FROM users');
+logger.timeEnd('database-query');
+// Output: 🐛 DEBUG {module} database-query ⏱  45ms #performance
+```
+
+### ✅ Structured Metadata
+
+```typescript
+logger.info('User logged in', {
+  userId: '123',
+  timestamp: Date.now(),
+  tags: ['auth', 'user-event']
+});
+```
+
+### ✅ Multiple Log Levels
+
+```typescript
+logger.trace('Very detailed debug info');
+logger.debug('Debug information');
+logger.info('General information');
+logger.warn('Warning message');
+logger.error('Error occurred', error);
+logger.fatal('Fatal error', error);
+```
+
+### ✅ Rich Development Output
+
+In development mode, logs include:
+- 🎨 **Colors** - Different colors per log level
+- 🎭 **Emojis** - Visual indicators for each level
+- 📍 **Context** - Plugin/module/component hierarchy
+- ⏱️  **Performance** - Duration tracking
+- 🏷️  **Tags** - Categorization and filtering
+
+### ✅ JSON Output for Production
+
+In production mode, logs are structured JSON:
+
+```json
+{
+  "timestamp": 1699564800000,
+  "level": "INFO",
+  "message": "User logged in",
+  "context": {
+    "plugin": "auth",
+    "module": "login"
+  },
+  "metadata": {
+    "userId": "123",
+    "tags": ["auth", "user-event"]
+  }
+}
+```
+
+## Configuration Options
+
+```typescript
+interface LoggingPluginConfig {
+  /** Global minimum log level */
+  globalLevel?: LogLevel;
+
+  /** Plugin-specific log levels */
+  pluginLevels?: Record<string, LogLevel>;
+
+  /** Module-specific log levels */
+  moduleLevels?: Record<string, LogLevel>;
+
+  /** Buffer size before forcing flush */
+  bufferSize?: number; // Default: 1000
+
+  /** Automatic flush interval in milliseconds */
+  flushInterval?: number; // Default: 5000
+
+  /** Use rich development formatter */
+  devFormatter?: boolean; // Default: true in development
+
+  /** Intercept console.log/warn/error (ENABLED BY DEFAULT) */
+  interceptConsole?: boolean; // Default: true
+}
+```
+
+## Advanced Usage
+
+### Custom Transports
+
+```typescript
+import { ILogTransport, LogEntry } from '@hamak/logging-api';
+
+class MyCustomTransport implements ILogTransport {
+  readonly id = 'my-transport';
+  readonly name = 'My Custom Transport';
+
+  log(entry: LogEntry): void {
+    // Send to custom destination
+    fetch('/api/logs', {
+      method: 'POST',
+      body: JSON.stringify(entry)
+    });
+  }
+}
+
+// Register in plugin initialization
+logManager.registerTransport(new MyCustomTransport(), {
+  id: 'my-transport',
+  enabled: true,
+  minLevel: LogLevel.WARN
+});
+```
+
+### Filtering Logs
+
+```typescript
+// Only log errors from 'payment' plugin
+logManager.registerTransport(transport, {
+  id: 'payment-errors',
+  minLevel: LogLevel.ERROR,
+  plugins: ['payment']
+});
+
+// Only log entries with specific tags
+logManager.registerTransport(transport, {
+  id: 'analytics',
+  filter: (entry) => entry.metadata?.tags?.includes('analytics')
+});
+```
+
+### Accessing Log Manager
+
+```typescript
+export const myPlugin: PluginModule = {
+  initialize(ctx) {
+    const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+
+    // Create logger
+    const logger = logManager.createLogger({ plugin: 'my-plugin' });
+
+    // Change log levels at runtime
+    logManager.setPluginLevel('my-plugin', LogLevel.TRACE);
+    logManager.setGlobalLevel(LogLevel.WARN);
+
+    // Flush logs manually
+    await logManager.flush();
+  }
+};
+```
+
+## Architecture
+
+- **SPI/API/IMPL Pattern** - Clean separation of concerns
+- **Dependency Injection** - Loggers injected via microkernel DI
+- **Pluggable Transports** - Multiple output destinations
+- **Event-Based** - Integrates with microkernel event system
+- **Performance Optimized** - Buffering, batching, lazy formatting
+- **Type-Safe** - Full TypeScript support
+
+## Examples
+
+See `apps/demo/src/` for complete integration examples.
+
+## Documentation
+
+- [Planning Document](../../plans/005-pluggable-logging-system.md)
+- [Implementation Details](./logging-impl/src/)
+- [API Reference](./logging-api/src/api/)
+
+## License
+
+MIT

package/dist/api/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hamak/logging/api
+ *
+ * Public API for the pluggable logging system.
+ * Provides interfaces, types, and service tokens for logging.
+ *
+ * @packageDocumentation
+ */
+export * from './interfaces/index';
+export * from './types/index';
+export * from './tokens/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,oBAAoB,CAAC;AAGnC,cAAc,eAAe,CAAC;AAG9B,cAAc,gBAAgB,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,14 @@
+/**
+ * @hamak/logging/api
+ *
+ * Public API for the pluggable logging system.
+ * Provides interfaces, types, and service tokens for logging.
+ *
+ * @packageDocumentation
+ */
+// Export all API interfaces
+export * from './interfaces/index';
+// Export all types
+export * from './types/index';
+// Export service tokens
+export * from './tokens/index';

package/dist/api/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './logger';
+export * from './transport';
+export * from './manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/dist/api/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './logger';
+export * from './transport';
+export * from './manager';

package/dist/api/interfaces/logger.d.ts

@@ -0,0 +1,105 @@
+import { LogLevel, LogContext, LogMetadata } from '../types/index';
+/**
+ * Core logging interface
+ *
+ * All logging in the application should go through this interface.
+ * Context is automatically tracked and can be extended with child loggers.
+ *
+ * @example
+ * ```typescript
+ * const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ * logger.info('Application started');
+ * logger.debug('Config loaded', { config: myConfig });
+ *
+ * // Create child logger with additional context
+ * const moduleLogger = logger.child({ module: 'auth' });
+ * moduleLogger.warn('Failed login attempt', { userId: '123' });
+ * ```
+ */
+export interface ILogger {
+    /**
+     * Log a trace message (most verbose)
+     * Use for very detailed debugging information
+     */
+    trace(message: string, meta?: LogMetadata): void;
+    /**
+     * Log a debug message
+     * Use for debugging information useful during development
+     */
+    debug(message: string, meta?: LogMetadata): void;
+    /**
+     * Log an informational message
+     * Use for general application flow information
+     */
+    info(message: string, meta?: LogMetadata): void;
+    /**
+     * Log a warning message
+     * Use for potentially harmful situations
+     */
+    warn(message: string, meta?: LogMetadata): void;
+    /**
+     * Log an error message
+     * Use for error events that might still allow the app to continue
+     */
+    error(message: string, error?: Error, meta?: LogMetadata): void;
+    /**
+     * Log a fatal error message
+     * Use for severe errors that will likely lead to application abort
+     */
+    fatal(message: string, error?: Error, meta?: LogMetadata): void;
+    /**
+     * Create a child logger with additional context
+     * The child inherits all context from the parent and adds new context
+     *
+     * @example
+     * ```typescript
+     * const pluginLogger = logger.child({ plugin: 'auth' });
+     * const moduleLogger = pluginLogger.child({ module: 'login' });
+     * // moduleLogger has context: { plugin: 'auth', module: 'login' }
+     * ```
+     */
+    child(context: LogContext): ILogger;
+    /**
+     * Execute a function with temporary additional context
+     * Useful for scoped operations
+     *
+     * @example
+     * ```typescript
+     * logger.scoped({ requestId: '123' }, (scopedLogger) => {
+     *   scopedLogger.info('Processing request');
+     *   // logs will include requestId: '123'
+     * });
+     * ```
+     */
+    scoped(context: LogContext, fn: (logger: ILogger) => void): void;
+    /**
+     * Check if a log level is enabled
+     * Useful for expensive operations that should only run if logging is enabled
+     *
+     * @example
+     * ```typescript
+     * if (logger.isLevelEnabled(LogLevel.DEBUG)) {
+     *   logger.debug('Expensive data', expensiveSerialize(data));
+     * }
+     * ```
+     */
+    isLevelEnabled(level: LogLevel): boolean;
+    /**
+     * Start a performance timer
+     * Call timeEnd() with the same label to log the duration
+     *
+     * @example
+     * ```typescript
+     * logger.time('database-query');
+     * await db.query('SELECT * FROM users');
+     * logger.timeEnd('database-query'); // logs duration
+     * ```
+     */
+    time(label: string): void;
+    /**
+     * End a performance timer and log the duration
+     * Must be called after time() with the same label
+     */
+    timeEnd(label: string): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/api/interfaces/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/api/interfaces/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhE;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhE;;;;;;;;;;OAUG;IACH,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IAEjE;;;;;;;;;;OAUG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEzC;;;;;;;;;;OAUG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B"}

package/dist/api/interfaces/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/api/interfaces/manager.d.ts

@@ -0,0 +1,120 @@
+import { ILogger } from './logger';
+import { ILogTransport } from './transport';
+import { LogLevel, LogContext, TransportConfig, LogEntry } from '../types/index';
+/**
+ * Log manager interface
+ *
+ * The central coordinator for the logging system.
+ * Manages transports, creates loggers, and dispatches log entries.
+ *
+ * @example
+ * ```typescript
+ * const logManager = new LogManager({ globalLevel: LogLevel.DEBUG });
+ *
+ * // Register transports
+ * logManager.registerTransport(new ConsoleTransport());
+ * logManager.registerTransport(new RemoteTransport(config));
+ *
+ * // Create loggers
+ * const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ * logger.info('Application started');
+ * ```
+ */
+export interface ILogManager {
+    /**
+     * Register a transport
+     * @param transport The transport to register
+     * @param config Optional configuration for this transport
+     */
+    registerTransport(transport: ILogTransport, config?: TransportConfig): void;
+    /**
+     * Unregister a transport by ID
+     * @param id Transport identifier
+     */
+    unregisterTransport(id: string): void;
+    /**
+     * Get a transport by ID
+     * @param id Transport identifier
+     * @returns The transport or undefined if not found
+     */
+    getTransport(id: string): ILogTransport | undefined;
+    /**
+     * Get all registered transports
+     * @returns Array of all transports
+     */
+    listTransports(): ILogTransport[];
+    /**
+     * Create a new logger with the given context
+     * Creates a new logger instance each time
+     *
+     * @param context Initial context for the logger
+     * @returns A new logger instance
+     */
+    createLogger(context?: LogContext): ILogger;
+    /**
+     * Get or create a cached logger for the given context
+     * Returns the same logger instance for the same context
+     *
+     * @param context Context for the logger
+     * @returns A cached logger instance
+     */
+    getLogger(context?: LogContext): ILogger;
+    /**
+     * Set the global minimum log level
+     * Logs below this level will be ignored (unless overridden by plugin/module)
+     *
+     * @param level The minimum log level
+     */
+    setGlobalLevel(level: LogLevel): void;
+    /**
+     * Set the minimum log level for a specific plugin
+     *
+     * @param plugin Plugin name
+     * @param level Minimum log level for this plugin
+     */
+    setPluginLevel(plugin: string, level: LogLevel): void;
+    /**
+     * Set the minimum log level for a specific module
+     *
+     * @param module Module name
+     * @param level Minimum log level for this module
+     */
+    setModuleLevel(module: string, level: LogLevel): void;
+    /**
+     * Flush all buffered logs to all transports
+     * @returns Promise that resolves when all logs are flushed
+     */
+    flush(): Promise<void>;
+    /**
+     * Clear the internal log buffer
+     * Useful for testing or memory management
+     */
+    clearBuffer(): void;
+    /**
+     * Register an event listener
+     * Events: 'log', 'error', 'flush'
+     *
+     * @example
+     * ```typescript
+     * logManager.on('log', (entry: LogEntry) => {
+     *   console.log('Log captured:', entry);
+     * });
+     * ```
+     */
+    on(event: 'log' | 'error' | 'flush', handler: (...args: any[]) => void): void;
+    /**
+     * Remove an event listener
+     *
+     * @param event Event name
+     * @param handler Handler function to remove
+     */
+    off(event: string, handler: (...args: any[]) => void): void;
+    /**
+     * Dispatch a log entry to all transports
+     * Internal method used by loggers
+     *
+     * @param entry The log entry to dispatch
+     */
+    dispatch(entry: LogEntry): void;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/api/interfaces/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../src/api/interfaces/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEjF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAE5E;;;OAGG;IACH,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAEpD;;;OAGG;IACH,cAAc,IAAI,aAAa,EAAE,CAAC;IAElC;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAE5C;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAEzC;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtC;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtD;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtD;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;OAGG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;;;;;;;OAUG;IACH,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAE9E;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;CACjC"}

package/dist/api/interfaces/manager.js

@@ -0,0 +1 @@
+export {};

package/dist/api/interfaces/transport.d.ts

@@ -0,0 +1,97 @@
+import { LogEntry } from '../types/index';
+/**
+ * Log transport interface
+ *
+ * Transports are responsible for outputting logs to different destinations
+ * (console, file, remote API, event bus, etc.)
+ *
+ * @example
+ * ```typescript
+ * class MyCustomTransport implements ILogTransport {
+ *   readonly id = 'my-transport';
+ *   readonly name = 'My Custom Transport';
+ *
+ *   log(entry: LogEntry): void {
+ *     // Send log to custom destination
+ *     myService.sendLog(entry);
+ *   }
+ *
+ *   async flush(): Promise<void> {
+ *     await myService.flushBuffer();
+ *   }
+ * }
+ * ```
+ */
+export interface ILogTransport {
+    /** Unique identifier for the transport */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /**
+     * Handle a log entry
+     * Can be synchronous or asynchronous
+     */
+    log(entry: LogEntry): void | Promise<void>;
+    /**
+     * Flush any buffered logs
+     * Optional - implement if transport buffers logs
+     */
+    flush?(): Promise<void>;
+    /**
+     * Close the transport and release resources
+     * Optional - implement if transport needs cleanup
+     */
+    close?(): Promise<void>;
+    /**
+     * Determine if this transport should handle a log entry
+     * Optional - implement for custom filtering beyond TransportConfig
+     *
+     * @example
+     * ```typescript
+     * shouldLog(entry: LogEntry): boolean {
+     *   // Only log errors from production
+     *   return entry.level >= LogLevel.ERROR &&
+     *          entry.context.environment === 'production';
+     * }
+     * ```
+     */
+    shouldLog?(entry: LogEntry): boolean;
+    /**
+     * Handle transport errors
+     * Optional - implement for custom error handling
+     *
+     * @example
+     * ```typescript
+     * onError(error: Error): void {
+     *   console.error('[Transport Error]', error);
+     *   // Maybe send to error tracking service
+     * }
+     * ```
+     */
+    onError?(error: Error): void;
+}
+/**
+ * Log formatter interface
+ *
+ * Formatters convert LogEntry objects into formatted strings
+ * for display or transmission.
+ */
+export interface ILogFormatter {
+    /**
+     * Format a log entry into a string
+     *
+     * @example
+     * ```typescript
+     * format(entry: LogEntry): string {
+     *   return `[${entry.level}] ${entry.message}`;
+     * }
+     * ```
+     */
+    format(entry: LogEntry): string | any;
+    /**
+     * Format batch of log entries
+     * Optional - implement for efficient batch formatting
+     */
+    formatBatch?(entries: LogEntry[]): string | any;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/api/interfaces/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/api/interfaces/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;OAGG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IAErC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,GAAG,CAAC;IAEtC;;;OAGG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;CACjD"}

package/dist/api/interfaces/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/api/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from './service-tokens';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/api/tokens/index.js

@@ -0,0 +1 @@
+export * from './service-tokens';