@mks2508/better-logger 2.0.1 → 3.0.0

package/src/types/core.ts

@@ -247,4 +247,50 @@ export interface LogStyles {
     location?: LogPartConfig;
     backdrop?: string;
     transparency?: number;
+}
+
+export interface TimerResult {
+    label: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+}
+
+export interface IScopedLogger {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    success(...args: any[]): void;
+    critical(...args: any[]): void;
+    trace(...args: any[]): void;
+
+    badges(badges: string[]): this;
+    badge(badge: string): this;
+    clearBadges(): this;
+
+    time(label: string): void;
+    timeEnd(label: string): number | undefined;
+
+    style(presetName: string): this;
+}
+
+export interface IAPILogger extends IScopedLogger {
+    slow(message: string, duration?: number): void;
+    rateLimit(message: string): void;
+    auth(message: string): void;
+    deprecated(message: string): void;
+}
+
+export interface IComponentLogger extends IScopedLogger {
+    lifecycle(event: string, message?: string): void;
+    stateChange(from: string, to: string, data?: any): void;
+    propsChange(changes: Record<string, any>): void;
+}
+
+export interface Bindings {
+    scope?: string;
+    badges?: string[];
+    type?: 'scope' | 'api' | 'component';
+    context?: string[];
 }

package/src/types/hooks.ts

@@ -0,0 +1,45 @@
+import type { LogLevel, StackInfo } from './core.js';
+
+export interface HookLogEntry {
+    level: LogLevel;
+    message: string;
+    args: any[];
+    timestamp: string;
+    prefix?: string;
+    stackInfo?: StackInfo;
+    correlationId?: string;
+    context?: Record<string, any>;
+    [key: string]: any;
+}
+
+export type HookEvent = 'beforeLog' | 'afterLog' | 'onError';
+
+export type HookCallback = (entry: HookLogEntry) => void | HookLogEntry | Promise<void | HookLogEntry>;
+
+export type MiddlewareFn = (
+    entry: HookLogEntry,
+    next: () => void | Promise<void>
+) => void | Promise<void>;
+
+export interface HookRegistration {
+    id: string;
+    event: HookEvent;
+    callback: HookCallback;
+    priority: number;
+    once: boolean;
+}
+
+export interface MiddlewareRegistration {
+    id: string;
+    fn: MiddlewareFn;
+    priority: number;
+}
+
+export interface IHookManager {
+    on(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    once(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    off(event: HookEvent, callback: HookCallback): boolean;
+    use(middleware: MiddlewareFn, priority?: number): () => void;
+    emit(event: HookEvent, entry: HookLogEntry): Promise<HookLogEntry>;
+    process(entry: HookLogEntry): Promise<HookLogEntry>;
+}

package/src/types/index.ts

@@ -14,12 +14,17 @@ export type {
     LoggerConfig,
     StackInfo,
     TimerEntry,
+    TimerResult,
     StyleOptions,
     AdaptiveColors,
     SpacingType,
     LogLayout,
     LogPartConfig,
     LogStyles,
+    IScopedLogger,
+    IAPILogger,
+    IComponentLogger,
+    Bindings,
 } from './core.js';
 
 export { LOG_LEVELS } from './core.js';
@@ -33,4 +38,37 @@ export type {
     ExportOptions,
     ExportResult,
     BufferStats,
-} from './handlers.js';
+} from './handlers.js';
+
+// Serializer types
+export type {
+    SerializerFn,
+    SerializerContext,
+    SerializerEntry,
+    SerializerConfig,
+    ISerializerRegistry,
+} from './serializers.js';
+
+// Hook types
+export type {
+    HookLogEntry,
+    HookEvent,
+    HookCallback,
+    MiddlewareFn,
+    HookRegistration,
+    MiddlewareRegistration,
+    IHookManager,
+} from './hooks.js';
+
+// Transport types
+export type {
+    TransportRecord,
+    TransportOptions,
+    TransportTarget,
+    ITransport,
+    IBufferedTransport,
+    ITransportManager,
+} from './transports.js';
+
+// Style Cache types
+export type { StyleCacheConfig } from '../styling/StyleCache.js';

package/src/types/serializers.ts

@@ -0,0 +1,30 @@
+import type { LogLevel } from './core.js';
+
+export type SerializerFn<T = any> = (value: T, context: SerializerContext) => any;
+
+export interface SerializerContext {
+    depth: number;
+    maxDepth: number;
+    path: string[];
+    seen: WeakSet<object>;
+}
+
+export interface SerializerEntry<T = any> {
+    type: new (...args: any[]) => T;
+    serializer: SerializerFn<T>;
+    priority: number;
+}
+
+export interface SerializerConfig {
+    maxDepth?: number;
+    circular?: 'error' | 'skip' | 'placeholder';
+    preserveUndefined?: boolean;
+}
+
+export interface ISerializerRegistry {
+    add<T>(type: new (...args: any[]) => T, serializer: SerializerFn<T>, priority?: number): void;
+    remove<T>(type: new (...args: any[]) => T): boolean;
+    has<T>(type: new (...args: any[]) => T): boolean;
+    serialize(value: any, config?: SerializerConfig): any;
+    getAll(): SerializerEntry[];
+}

package/src/types/transports.ts

@@ -0,0 +1,52 @@
+import type { LogLevel, StackInfo } from './core.js';
+
+export interface TransportRecord {
+    level: LogLevel;
+    levelValue: number;
+    time: number;
+    msg: string;
+    prefix?: string;
+    location?: {
+        file: string;
+        line: number;
+        column: number;
+        function?: string;
+    };
+    [key: string]: any;
+}
+
+export interface TransportOptions {
+    level?: LogLevel;
+    transform?: (record: TransportRecord) => TransportRecord | null;
+    batchSize?: number;
+    flushInterval?: number;
+    [key: string]: any;
+}
+
+export interface TransportTarget {
+    target: string | ITransport;
+    options?: TransportOptions;
+    level?: LogLevel;
+}
+
+export interface ITransport {
+    readonly name: string;
+    write(record: TransportRecord): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    close?(): void | Promise<void>;
+    isReady?(): boolean;
+}
+
+export interface IBufferedTransport extends ITransport {
+    readonly bufferSize: number;
+    readonly maxBufferSize: number;
+    flush(): Promise<void>;
+}
+
+export interface ITransportManager {
+    add(target: TransportTarget): string;
+    remove(id: string): boolean;
+    write(record: TransportRecord): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}