modality-kit 0.6.2 → 0.6.3

package/dist/index.js

@@ -4293,34 +4293,23 @@ var DEFAULT_CONFIG = {
   maxSentencesForAnalysis: 500,
   fastModeMaxSentences: 200
 };
-class LanguageDetectionError extends Error {
-  fallbackLanguage;
-  constructor(message, fallbackLanguage) {
-    super(message);
-    this.fallbackLanguage = fallbackLanguage;
-    this.name = "LanguageDetectionError";
+
+class CompressionError extends ErrorCode {
+  code;
+  details;
+  constructor(message, code, details, originalError) {
+    super(message, originalError);
+    this.code = code;
+    this.details = details;
   }
 }
 
-class CompressionLogger {
-  enabled;
-  constructor(enabled = false) {
-    this.enabled = enabled;
-  }
-  info(message, data) {
-    if (this.enabled) {
-      console.info(`[TextCompression] ${message}`, data || "");
-    }
-  }
-  warn(message, data) {
-    if (this.enabled) {
-      console.warn(`[TextCompression] ${message}`, data || "");
-    }
-  }
-  error(message, error) {
-    if (this.enabled) {
-      console.error(`[TextCompression] ${message}`, error || "");
-    }
+class LanguageDetectionError extends ErrorCode {
+  code = "LANGUAGE_DETECTION_ERROR";
+  fallbackLanguage;
+  constructor(message, fallbackLanguage, originalError) {
+    super(message, originalError);
+    this.fallbackLanguage = fallbackLanguage;
   }
 }
 
@@ -4735,7 +4724,7 @@ class TextCompressionUtility {
   config;
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.logger = new CompressionLogger(this.config.enableLogging);
+    this.logger = ModalityLogger.getInstance("TextCompression", this.config.enableLogging ? "info" : "error");
     this.languageDetector = new UniversalLanguageDetector(this.logger);
     this.importanceAnalyzer = new IntelligentImportanceAnalyzer(this.logger, this.config);
   }
@@ -4762,7 +4751,7 @@ class TextCompressionUtility {
       fastMode = false
     } = options;
     if (maxTokens <= 0) {
-      throw new Error("maxTokens must be greater than 0");
+      throw new CompressionError("maxTokens must be greater than 0", "INVALID_MAX_TOKENS");
     }
     const trimmedText = text.trim();
     const originalLength = trimmedText.length;
@@ -4991,7 +4980,7 @@ class TextCompressionUtility {
     return Math.ceil(text.length / 4);
   }
 }
-async function compressWithLanguageDetection(text, maxTokens = 4000) {
+async function compressWithLanguageDetection(text, maxTokens = DEFAULT_CONFIG.maxTokens) {
   const compressor = new TextCompressionUtility;
   return await compressor.compress(text, {
     maxTokens,

package/dist/types/util_tests/__tests__/console-mock.test.d.ts

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

package/dist/types/util_tests/console-mock.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Console Mock Utility
+ *
+ * Provides utilities for mocking console output during testing to keep test output clean.
+ * Can be used across multiple test files for consistent console mocking.
+ */
+export declare class ConsoleMock {
+    private originalMethods;
+    private isMocked;
+    /**
+     * Mock all console methods to prevent output during tests
+     */
+    mock(): void;
+    /**
+     * Restore original console methods
+     */
+    restore(): void;
+    /**
+     * Check if console is currently mocked
+     */
+    get isActive(): boolean;
+    /**
+     * Temporarily restore console methods for debugging purposes
+     * Returns a function to re-mock console methods
+     */
+    temporaryRestore(): () => void;
+}
+export declare const consoleMock: ConsoleMock;
+/**
+ * Convenience functions for common usage patterns
+ */
+/**
+ * Setup console mocking for a test suite (use in beforeAll)
+ */
+export declare function setupConsoleMock(): void;
+/**
+ * Cleanup console mocking for a test suite (use in afterAll)
+ */
+export declare function cleanupConsoleMock(): void;
+/**
+ * Higher-order function to run a function with console temporarily restored
+ * Useful for debugging specific tests
+ */
+export declare function withConsole<T>(fn: () => T): T;
+/**
+ * Higher-order function to run an async function with console temporarily restored
+ * Useful for debugging specific async tests
+ */
+export declare function withConsoleAsync<T>(fn: () => Promise<T>): Promise<T>;

package/dist/types/util_text_compression.d.ts

@@ -1,3 +1,5 @@
+import { ModalityLogger } from './util_logger.js';
+import { ErrorCode } from './util_error.js';
 export interface CompressionConfig {
     maxTokens: number;
     compressionLevel: "light" | "moderate" | "aggressive";
@@ -54,26 +56,20 @@ export interface LanguageDetectionResult {
     script?: string;
     region?: string;
 }
-export declare class CompressionError extends Error {
-    code: string;
-    details?: any | undefined;
-    constructor(message: string, code: string, details?: any | undefined);
+export declare class CompressionError extends ErrorCode {
+    readonly code: string;
+    details?: any;
+    constructor(message: string, code: string, details?: any, originalError?: unknown);
 }
-export declare class LanguageDetectionError extends Error {
+export declare class LanguageDetectionError extends ErrorCode {
+    readonly code: string;
     fallbackLanguage: string;
-    constructor(message: string, fallbackLanguage: string);
-}
-export declare class CompressionLogger {
-    private enabled;
-    constructor(enabled?: boolean);
-    info(message: string, data?: any): void;
-    warn(message: string, data?: any): void;
-    error(message: string, error?: Error): void;
+    constructor(message: string, fallbackLanguage: string, originalError?: unknown);
 }
 export declare class UniversalLanguageDetector {
     private logger;
     private cache;
-    constructor(logger: CompressionLogger);
+    constructor(logger: ModalityLogger);
     detectLanguage(text: string): Promise<LanguageDetectionResult>;
     private performDetection;
     private analyzeUnicodeRanges;
@@ -87,7 +83,7 @@ export declare class IntelligentImportanceAnalyzer {
     private wordFrequencyCache;
     private logger;
     private config;
-    constructor(logger: CompressionLogger, config: CompressionConfig);
+    constructor(logger: ModalityLogger, config: CompressionConfig);
     analyzeImportance(text: string, detectedLanguage?: string): Promise<Array<{
         text: string;
         score: number;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.2",
+  "version": "0.6.3",
   "name": "modality-kit",
   "repository": {
     "type": "git",