@adaas/a-utils 0.2.8 → 0.3.1

package/dist/node/lib/A-Execution/A-Execution.context.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var aFrame = require('@adaas/a-frame');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+exports.A_ExecutionContext = class A_ExecutionContext extends aConcept.A_Fragment {
+  constructor(name, defaults) {
+    super({ name });
+    this._meta = new aConcept.A_Meta();
+    for (const key in defaults) {
+      this._meta.set(key, defaults[key]);
+    }
+  }
+  [Symbol.iterator]() {
+    return this._meta[Symbol.iterator]();
+  }
+  get meta() {
+    return this._meta;
+  }
+  get(key) {
+    return this._meta.get(key);
+  }
+  set(key, value) {
+    this._meta.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this._meta.has(key);
+  }
+  drop(key) {
+    this._meta.delete(key);
+  }
+  clear() {
+    this._meta.clear();
+    return this;
+  }
+  toRaw() {
+    return this._meta.toJSON();
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      ...this.meta.toJSON()
+    };
+  }
+};
+exports.A_ExecutionContext = __decorateClass([
+  aFrame.A_Frame.Fragment({
+    namespace: "A-Utils",
+    name: "A-ExecutionContext",
+    description: "Execution context fragment that provides a structured way to manage metadata and serialized data for execution environments. It allows storing and retrieving key-value pairs, facilitating context-aware operations within the application. It useful in cases when it's necessary to share some runtime data across multiple steps of thee features, or components."
+  })
+], exports.A_ExecutionContext);
+//# sourceMappingURL=A-Execution.context.js.map
+//# sourceMappingURL=A-Execution.context.js.map

package/dist/node/lib/A-Execution/A-Execution.context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-Execution/A-Execution.context.ts"],"names":["A_ExecutionContext","A_Fragment","A_Meta","A_Frame"],"mappings":";;;;;;;;;;;;;AAWaA,0BAAA,GAAN,iCAGGC,mBAAA,CAAW;AAAA,EAKjB,WAAA,CACI,MACA,QAAA,EACF;AACE,IAAA,KAAA,CAAM,EAAE,MAAM,CAAA;AACd,IAAA,IAAA,CAAK,KAAA,GAAQ,IAAIC,eAAA,EAAmC;AAEpD,IAAA,KAAA,MAAW,OAAO,QAAA,EAAU;AACxB,MAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAwB,QAAA,CAAS,GAAsB,CAA+B,CAAA;AAAA,IACzG;AAAA,EACJ;AAAA,EAGA,CAAC,MAAA,CAAO,QAAQ,CAAA,GAA6D;AACzE,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,QAAQ,CAAA,EAAE;AAAA,EACvC;AAAA,EAGA,IAAI,IAAA,GAA0B;AAC1B,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA,EAGA,IAA+B,GAAA,EAAkC;AAC7D,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA;AAAA,EAC7B;AAAA,EAEA,GAAA,CAA+B,KAAQ,KAAA,EAA2B;AAC9D,IAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AACzB,IAAA,OAAO,IAAA;AAAA,EACX;AAAA,EAEA,IAAI,GAAA,EAA+B;AAC/B,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA;AAAA,EAC7B;AAAA,EAEA,KAAK,GAAA,EAA4B;AAC7B,IAAA,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAA;AAAA,EACzB;AAAA,EAEA,KAAA,GAAc;AACV,IAAA,IAAA,CAAK,MAAM,KAAA,EAAM;AACjB,IAAA,OAAO,IAAA;AAAA,EACX;AAAA,EAGA,KAAA,GAAyB;AACrB,IAAA,OAAO,IAAA,CAAK,MAAM,MAAA,EAAO;AAAA,EAC7B;AAAA,EAEA,MAAA,GAAuC;AACnC,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,GAAG,IAAA,CAAK,IAAA,CAAK,MAAA;AAAO,KACxB;AAAA,EACJ;AACJ;AAhEaF,0BAAA,GAAN,eAAA,CAAA;AAAA,EALNG,eAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,SAAA;AAAA,IACX,IAAA,EAAM,oBAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACYH,0BAAA,CAAA","file":"A-Execution.context.js","sourcesContent":["import { A_Fragment, A_Meta, A_TYPES__Fragment_Serialized } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-Utils',\n    name: 'A-ExecutionContext',\n    description: 'Execution context fragment that provides a structured way to manage metadata and serialized data for execution environments. It allows storing and retrieving key-value pairs, facilitating context-aware operations within the application. It useful in cases when it\\'s necessary to share some runtime data across multiple steps of thee features, or components.'\n})\nexport class A_ExecutionContext<\n    _MetaType extends Record<string, any> = Record<string, any>,\n    _SerializedType extends Record<string, any> = Record<string, any>\n> extends A_Fragment {\n\n\n    protected _meta: A_Meta<_MetaType, _SerializedType>;\n\n    constructor(\n        name: string,\n        defaults?: Partial<_MetaType>,\n    ) {\n        super({ name });\n        this._meta = new A_Meta<_MetaType, _SerializedType>();\n\n        for (const key in defaults) {\n            this._meta.set(key as keyof _MetaType, defaults[key as keyof _MetaType] as _MetaType[keyof _MetaType]);\n        }\n    }\n\n\n    [Symbol.iterator](): Iterator<[keyof _MetaType, _MetaType[keyof _MetaType]]> {\n        return this._meta[Symbol.iterator]();\n    }\n\n\n    get meta(): A_Meta<_MetaType> {\n        return this._meta;\n    }\n\n\n    get<K extends keyof _MetaType>(key: K): _MetaType[K] | undefined {\n        return this._meta.get(key);\n    }\n\n    set<K extends keyof _MetaType>(key: K, value: _MetaType[K]): this {\n        this._meta.set(key, value);\n        return this;\n    }\n\n    has(key: keyof _MetaType): boolean {\n        return this._meta.has(key);\n    }\n\n    drop(key: keyof _MetaType): void {\n        this._meta.delete(key);\n    }\n\n    clear(): this {\n        this._meta.clear();\n        return this;\n    }\n\n\n    toRaw(): _SerializedType {\n        return this._meta.toJSON();\n    }\n\n    toJSON(): A_TYPES__Fragment_Serialized {\n        return {\n            name: this.name,\n            ...this.meta.toJSON(),\n        }\n    }\n}"]}

package/dist/node/lib/A-Execution/A-Execution.context.mjs

@@ -0,0 +1,56 @@
+import { __decorateClass } from '../../chunk-EQQGB2QZ.mjs';
+import { A_Fragment, A_Meta } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame';
+
+let A_ExecutionContext = class extends A_Fragment {
+  constructor(name, defaults) {
+    super({ name });
+    this._meta = new A_Meta();
+    for (const key in defaults) {
+      this._meta.set(key, defaults[key]);
+    }
+  }
+  [Symbol.iterator]() {
+    return this._meta[Symbol.iterator]();
+  }
+  get meta() {
+    return this._meta;
+  }
+  get(key) {
+    return this._meta.get(key);
+  }
+  set(key, value) {
+    this._meta.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this._meta.has(key);
+  }
+  drop(key) {
+    this._meta.delete(key);
+  }
+  clear() {
+    this._meta.clear();
+    return this;
+  }
+  toRaw() {
+    return this._meta.toJSON();
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      ...this.meta.toJSON()
+    };
+  }
+};
+A_ExecutionContext = __decorateClass([
+  A_Frame.Fragment({
+    namespace: "A-Utils",
+    name: "A-ExecutionContext",
+    description: "Execution context fragment that provides a structured way to manage metadata and serialized data for execution environments. It allows storing and retrieving key-value pairs, facilitating context-aware operations within the application. It useful in cases when it's necessary to share some runtime data across multiple steps of thee features, or components."
+  })
+], A_ExecutionContext);
+
+export { A_ExecutionContext };
+//# sourceMappingURL=A-Execution.context.mjs.map
+//# sourceMappingURL=A-Execution.context.mjs.map

package/dist/node/lib/A-Execution/A-Execution.context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-Execution/A-Execution.context.ts"],"names":[],"mappings":";;;;AAWO,IAAM,kBAAA,GAAN,cAGG,UAAA,CAAW;AAAA,EAKjB,WAAA,CACI,MACA,QAAA,EACF;AACE,IAAA,KAAA,CAAM,EAAE,MAAM,CAAA;AACd,IAAA,IAAA,CAAK,KAAA,GAAQ,IAAI,MAAA,EAAmC;AAEpD,IAAA,KAAA,MAAW,OAAO,QAAA,EAAU;AACxB,MAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAwB,QAAA,CAAS,GAAsB,CAA+B,CAAA;AAAA,IACzG;AAAA,EACJ;AAAA,EAGA,CAAC,MAAA,CAAO,QAAQ,CAAA,GAA6D;AACzE,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,QAAQ,CAAA,EAAE;AAAA,EACvC;AAAA,EAGA,IAAI,IAAA,GAA0B;AAC1B,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA,EAGA,IAA+B,GAAA,EAAkC;AAC7D,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA;AAAA,EAC7B;AAAA,EAEA,GAAA,CAA+B,KAAQ,KAAA,EAA2B;AAC9D,IAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AACzB,IAAA,OAAO,IAAA;AAAA,EACX;AAAA,EAEA,IAAI,GAAA,EAA+B;AAC/B,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA;AAAA,EAC7B;AAAA,EAEA,KAAK,GAAA,EAA4B;AAC7B,IAAA,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAA;AAAA,EACzB;AAAA,EAEA,KAAA,GAAc;AACV,IAAA,IAAA,CAAK,MAAM,KAAA,EAAM;AACjB,IAAA,OAAO,IAAA;AAAA,EACX;AAAA,EAGA,KAAA,GAAyB;AACrB,IAAA,OAAO,IAAA,CAAK,MAAM,MAAA,EAAO;AAAA,EAC7B;AAAA,EAEA,MAAA,GAAuC;AACnC,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,GAAG,IAAA,CAAK,IAAA,CAAK,MAAA;AAAO,KACxB;AAAA,EACJ;AACJ;AAhEa,kBAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,SAAA;AAAA,IACX,IAAA,EAAM,oBAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,kBAAA,CAAA","file":"A-Execution.context.mjs","sourcesContent":["import { A_Fragment, A_Meta, A_TYPES__Fragment_Serialized } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-Utils',\n    name: 'A-ExecutionContext',\n    description: 'Execution context fragment that provides a structured way to manage metadata and serialized data for execution environments. It allows storing and retrieving key-value pairs, facilitating context-aware operations within the application. It useful in cases when it\\'s necessary to share some runtime data across multiple steps of thee features, or components.'\n})\nexport class A_ExecutionContext<\n    _MetaType extends Record<string, any> = Record<string, any>,\n    _SerializedType extends Record<string, any> = Record<string, any>\n> extends A_Fragment {\n\n\n    protected _meta: A_Meta<_MetaType, _SerializedType>;\n\n    constructor(\n        name: string,\n        defaults?: Partial<_MetaType>,\n    ) {\n        super({ name });\n        this._meta = new A_Meta<_MetaType, _SerializedType>();\n\n        for (const key in defaults) {\n            this._meta.set(key as keyof _MetaType, defaults[key as keyof _MetaType] as _MetaType[keyof _MetaType]);\n        }\n    }\n\n\n    [Symbol.iterator](): Iterator<[keyof _MetaType, _MetaType[keyof _MetaType]]> {\n        return this._meta[Symbol.iterator]();\n    }\n\n\n    get meta(): A_Meta<_MetaType> {\n        return this._meta;\n    }\n\n\n    get<K extends keyof _MetaType>(key: K): _MetaType[K] | undefined {\n        return this._meta.get(key);\n    }\n\n    set<K extends keyof _MetaType>(key: K, value: _MetaType[K]): this {\n        this._meta.set(key, value);\n        return this;\n    }\n\n    has(key: keyof _MetaType): boolean {\n        return this._meta.has(key);\n    }\n\n    drop(key: keyof _MetaType): void {\n        this._meta.delete(key);\n    }\n\n    clear(): this {\n        this._meta.clear();\n        return this;\n    }\n\n\n    toRaw(): _SerializedType {\n        return this._meta.toJSON();\n    }\n\n    toJSON(): A_TYPES__Fragment_Serialized {\n        return {\n            name: this.name,\n            ...this.meta.toJSON(),\n        }\n    }\n}"]}

package/dist/node/lib/A-Execution/A-Execution.types.d.mts

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

package/dist/node/lib/A-Execution/A-Execution.types.d.ts

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

package/dist/node/lib/A-Execution/A-Execution.types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=A-Execution.types.js.map
+//# sourceMappingURL=A-Execution.types.js.map

package/dist/node/lib/A-Execution/A-Execution.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"A-Execution.types.js"}

package/dist/node/lib/A-Execution/A-Execution.types.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=A-Execution.types.mjs.map
+//# sourceMappingURL=A-Execution.types.mjs.map

package/dist/node/lib/A-Execution/A-Execution.types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"A-Execution.types.mjs"}

package/dist/node/lib/A-Execution/index.d.mts

@@ -0,0 +1,2 @@
+export { A_ExecutionContext } from './A-Execution.context.mjs';
+import '@adaas/a-concept';

package/dist/node/lib/A-Execution/index.d.ts

@@ -0,0 +1,2 @@
+export { A_ExecutionContext } from './A-Execution.context.js';
+import '@adaas/a-concept';

package/dist/node/lib/A-Execution/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var AExecution_context = require('./A-Execution.context');
+
+
+
+Object.defineProperty(exports, "A_ExecutionContext", {
+  enumerable: true,
+  get: function () { return AExecution_context.A_ExecutionContext; }
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/node/lib/A-Execution/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/node/lib/A-Execution/index.mjs

@@ -0,0 +1,4 @@
+import '../../chunk-EQQGB2QZ.mjs';
+export { A_ExecutionContext } from './A-Execution.context';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/node/lib/A-Execution/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs","sourcesContent":[]}

package/dist/node/lib/A-Logger/A-Logger.component.d.mts

@@ -0,0 +1,377 @@
+import { A_Component, A_Scope, A_Error } from '@adaas/a-concept';
+import { A_LoggerColorName } from './A-Logger.types.mjs';
+import { A_LoggerEnvVariablesType } from './A-Logger.env.mjs';
+import { A_Config } from '../A-Config/A-Config.context.mjs';
+import '../A-Config/A-Config.types.mjs';
+import '../A-Execution/A-Execution.context.mjs';
+import '../A-Config/A-Config.constants.mjs';
+
+/**
+ * A_Logger - Advanced Logging Component with Scope-based Output Formatting
+ *
+ * This component provides comprehensive logging capabilities with:
+ * - Color-coded console output for different log levels
+ * - Scope-based message formatting with consistent alignment
+ * - Support for multiple data types (objects, errors, strings)
+ * - Configurable log levels for filtering output
+ * - Special handling for A_Error and native Error objects
+ * - Timestamp inclusion for better debugging
+ *
+ * Key Features:
+ * - **Scope Integration**: Uses A_Scope for consistent message prefixing
+ * - **Color Support**: Terminal color codes for visual distinction
+ * - **Object Formatting**: Pretty-prints JSON objects with proper indentation
+ * - **Error Handling**: Special formatting for A_Error and Error objects
+ * - **Log Level Filtering**: Configurable filtering based on severity
+ * - **Multi-line Support**: Proper alignment for multi-line messages
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with dependency injection (uses deterministic colors based on scope name)
+ * class MyService {
+ *   constructor(@A_Inject(A_Logger) private logger: A_Logger) {}
+ *
+ *   doSomething() {
+ *     this.logger.info('Processing started'); // Uses scope-name-based colors, always shows
+ *     this.logger.debug('Debug information'); // Only shows when debug level enabled
+ *
+ *     // Color overload methods with enum support
+ *     this.logger.info('green', 'Success message'); // Green message, scope stays default
+ *     this.logger.debug('gray', 'Verbose debug info'); // Gray message for less important info
+ *     this.logger.info('brightBlue', 'Important notification');
+ *
+ *     // Terminal width aware formatting - automatically wraps long lines
+ *     this.logger.info('This is a very long message that will be automatically wrapped to fit within the terminal width while maintaining proper indentation and formatting');
+ *
+ *     this.logger.warning('Something might be wrong');
+ *     this.logger.error(new Error('Something failed'));
+ *   }
+ * }
+ *
+ * // Same scope names will always get the same colors automatically
+ * const logger1 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets consistent colors
+ * const logger2 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets same colors as logger1
+ *
+ * // Available color names (A_LoggerColorName enum):
+ * // 'red', 'yellow', 'green', 'blue', 'cyan', 'magenta', 'gray',
+ * // 'brightBlue', 'brightCyan', 'brightMagenta', 'darkGray', 'lightGray',
+ * // 'indigo', 'violet', 'purple', 'lavender', 'skyBlue', 'steelBlue',
+ * // 'slateBlue', 'deepBlue', 'lightBlue', 'periwinkle', 'cornflower',
+ * // 'powder', 'charcoal', 'silver', 'smoke', 'slate'
+ *
+ * // Configuration via environment variables or A_Config (overrides automatic selection)
+ * process.env.A_LOGGER_DEFAULT_SCOPE_COLOR = 'magenta';
+ * process.env.A_LOGGER_DEFAULT_LOG_COLOR = 'green';
+ *
+ * // Or through A_Config instance
+ * const config = new A_Config({
+ *   A_LOGGER_DEFAULT_SCOPE_COLOR: 'red',
+ *   A_LOGGER_DEFAULT_LOG_COLOR: 'white'
+ * });
+ * const logger = new A_Logger(scope, config);
+ * ```
+ */
+declare class A_Logger extends A_Component {
+    protected scope: A_Scope;
+    protected config?: A_Config<A_LoggerEnvVariablesType> | undefined;
+    /**
+     * Terminal color codes for different log levels and custom styling
+     * These codes work with ANSI escape sequences for colored terminal output
+     */
+    readonly COLORS: any;
+    /**
+     * Standard scope length for consistent formatting
+     * This ensures all log messages align properly regardless of scope name length
+     */
+    private readonly STANDARD_SCOPE_LENGTH;
+    /**
+     * Default color for the scope portion of log messages
+     * This color is used for the scope brackets and content, and remains consistent
+     * for this logger instance regardless of message color overrides
+     */
+    private readonly DEFAULT_SCOPE_COLOR;
+    /**
+     * Default color for log message content when no explicit color is provided
+     * This color is used for the message body when logging without specifying a color
+     */
+    private readonly DEFAULT_LOG_COLOR;
+    /**
+     * Current terminal width for responsive formatting
+     * Automatically detected or falls back to default values
+     */
+    private readonly TERMINAL_WIDTH;
+    /**
+     * Maximum content width based on terminal size
+     * Used for word wrapping and line length calculations
+     */
+    private readonly MAX_CONTENT_WIDTH;
+    /**
+     * Initialize A_Logger with dependency injection
+     * Colors are configured through A_Config or generated randomly if not provided
+     *
+     * @param scope - The current scope context for message prefixing
+     * @param config - Optional configuration for log level filtering and color settings
+     */
+    constructor(scope: A_Scope, config?: A_Config<A_LoggerEnvVariablesType> | undefined);
+    /**
+     * Generate a simple hash from a string
+     * Used to create deterministic color selection based on scope name
+     *
+     * @param str - The string to hash
+     * @returns A numeric hash value
+     */
+    private simpleHash;
+    /**
+     * Generate a deterministic color based on scope name
+     * Same scope names will always get the same color, but uses safe color palette
+     *
+     * @param scopeName - The scope name to generate color for
+     * @returns A color key from the safe colors palette
+     */
+    private generateColorFromScopeName;
+    /**
+     * Generate a pair of complementary colors based on scope name
+     * Ensures visual harmony between scope and message colors while being deterministic
+     *
+     * @param scopeName - The scope name to base colors on
+     * @returns Object with scopeColor and logColor that work well together
+     */
+    private generateComplementaryColorsFromScope;
+    /**
+     * Detect current terminal width based on environment
+     *
+     * Returns appropriate width for different environments:
+     * - Node.js: Uses process.stdout.columns if available
+     * - Browser: Returns browser default width
+     * - Fallback: Returns default terminal width
+     *
+     * @returns Terminal width in characters
+     */
+    private detectTerminalWidth;
+    /**
+     * Wrap text to fit within terminal width while preserving formatting
+     *
+     * @param text - Text to wrap
+     * @param scopePadding - The scope padding string for alignment
+     * @param isFirstLine - Whether this is the first line (affects available width calculation)
+     * @returns Array of wrapped lines with proper indentation
+     */
+    private wrapText;
+    /**
+     * Split a long word that doesn't fit on a single line
+     *
+     * @param word - Word to split
+     * @param maxLength - Maximum length per chunk
+     * @returns Array of word chunks
+     */
+    private splitLongWord;
+    /**
+     * Get the formatted scope length for consistent message alignment
+     * Uses a standard length to ensure all messages align properly regardless of scope name
+     *
+     * @returns The scope length to use for padding calculations
+     */
+    get scopeLength(): number;
+    /**
+     * Get the formatted scope name with proper padding, centered within the container
+     * Ensures consistent width for all scope names in log output with centered alignment
+     *
+     * @returns Centered and padded scope name for consistent formatting
+     */
+    get formattedScope(): string;
+    /**
+     * Compile log arguments into formatted console output with colors and proper alignment
+     *
+     * This method handles the core formatting logic for all log messages:
+     * - Applies separate colors for scope and message content
+     * - Formats scope names with consistent padding
+     * - Handles different data types appropriately
+     * - Maintains proper indentation for multi-line content
+     *
+     * @param messageColor - The color key to apply to the message content
+     * @param args - Variable arguments to format and display
+     * @returns Array of formatted strings and/or objects ready for console output
+     */
+    compile(messageColor: keyof typeof this.COLORS, ...args: any[]): Array<any>;
+    /**
+     * Format an object for display with proper JSON indentation and terminal width awareness
+     *
+     * @param obj - The object to format
+     * @param shouldAddNewline - Whether to add a newline prefix
+     * @param scopePadding - The padding string for consistent alignment
+     * @returns Formatted object string or the object itself for browser environments
+     */
+    private formatObject;
+    /**
+     * Wrap a long JSON string value while preserving readability
+     *
+     * @param value - The string value to wrap
+     * @param maxWidth - Maximum width for the value
+     * @returns Wrapped string value
+     */
+    private wrapJsonStringValue;
+    /**
+     * Format a string for display with proper indentation and terminal width wrapping
+     *
+     * @param str - The string to format
+     * @param shouldAddNewline - Whether to add a newline prefix
+     * @param scopePadding - The padding string for consistent alignment
+     * @returns Formatted string
+     */
+    private formatString;
+    /**
+     * Determine if a log message should be output based on configured log level
+     *
+     * Log level hierarchy:
+     * - debug: Shows all messages (debug, info, warning, error)
+     * - info: Shows info, warning, and error messages
+     * - warn: Shows warning and error messages only
+     * - error: Shows error messages only
+     * - all: Shows all messages (alias for debug)
+     *
+     * @param logMethod - The type of log method being called
+     * @returns True if the message should be logged, false otherwise
+     */
+    protected shouldLog(logMethod: 'debug' | 'info' | 'warning' | 'error'): boolean;
+    /**
+     * Debug logging method with optional color specification
+     * Only logs when debug level is enabled
+     *
+     * Supports two usage patterns:
+     * 1. debug(message, ...args) - Uses instance's default log color
+     * 2. debug(color, message, ...args) - Uses specified color for message content only
+     *
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
+     *
+     * @param color - Optional color name from A_LoggerColorName enum or the first message argument
+     * @param args - Additional arguments to log
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Debug information'); // Uses instance default colors
+     * logger.debug('gray', 'Debug message'); // Gray message, scope stays instance color
+     * logger.debug('Processing user:', { id: 1, name: 'John' });
+     * ```
+     */
+    debug(color: A_LoggerColorName, ...args: any[]): void;
+    debug(...args: any[]): void;
+    /**
+     * Info logging method with optional color specification
+     * Logs without any restrictions (always shows regardless of log level)
+     *
+     * Supports two usage patterns:
+     * 1. info(message, ...args) - Uses instance's default log color
+     * 2. info(color, message, ...args) - Uses specified color for message content only
+     *
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
+     *
+     * @param color - Optional color name from A_LoggerColorName enum or the first message argument
+     * @param args - Additional arguments to log
+     *
+     * @example
+     * ```typescript
+     * logger.info('Hello World'); // Uses instance default colors
+     * logger.info('green', 'Success message'); // Green message, scope stays instance color
+     * logger.info('Processing user:', { id: 1, name: 'John' });
+     * ```
+     */
+    info(color: A_LoggerColorName, ...args: any[]): void;
+    info(...args: any[]): void;
+    /**
+     * Legacy log method (kept for backward compatibility)
+     * @deprecated Use info() method instead
+     *
+     * @param color - Optional color name from A_LoggerColorName enum or the first message argument
+     * @param args - Additional arguments to log
+     */
+    log(color: A_LoggerColorName, ...args: any[]): void;
+    log(...args: any[]): void;
+    /**
+     * Log warning messages with yellow color coding
+     *
+     * Use for non-critical issues that should be brought to attention
+     * but don't prevent normal operation
+     *
+     * @param args - Arguments to log as warnings
+     *
+     * @example
+     * ```typescript
+     * logger.warning('Deprecated method used');
+     * logger.warning('Rate limit approaching:', { current: 95, limit: 100 });
+     * ```
+     */
+    warning(...args: any[]): void;
+    /**
+     * Log error messages with red color coding
+     *
+     * Use for critical issues, exceptions, and failures that need immediate attention
+     *
+     * @param args - Arguments to log as errors
+     * @returns void (for compatibility with console.log)
+     *
+     * @example
+     * ```typescript
+     * logger.error('Database connection failed');
+     * logger.error(new Error('Validation failed'));
+     * logger.error('Critical error:', error, { context: 'user-registration' });
+     * ```
+     */
+    error(...args: any[]): void;
+    /**
+     * Legacy method for A_Error logging (kept for backward compatibility)
+     *
+     * @deprecated Use error() method instead which handles A_Error automatically
+     * @param error - The A_Error instance to log
+     */
+    protected log_A_Error(error: A_Error): void;
+    /**
+     * Format A_Error instances for inline display within compiled messages
+     *
+     * Provides detailed formatting for A_Error objects with:
+     * - Error code, message, and description
+     * - Original error information FIRST (better UX for debugging)
+     * - Stack traces with terminal width awareness
+     * - Documentation links (if available)
+     * - Consistent formatting with rest of logger
+     *
+     * @param error - The A_Error instance to format
+     * @returns Formatted string ready for display
+     */
+    protected compile_A_Error(error: A_Error): string;
+    /**
+     * Format stack trace with proper terminal width wrapping and indentation
+     *
+     * @param stack - The stack trace string
+     * @param baseIndent - Base indentation for continuation lines
+     * @returns Array of formatted stack trace lines
+     */
+    private formatStackTrace;
+    /**
+     * Format standard Error instances for inline display within compiled messages
+     *
+     * Provides clean, readable formatting for standard JavaScript errors with:
+     * - Terminal width aware message wrapping
+     * - Properly formatted stack traces
+     * - Consistent indentation with rest of logger
+     *
+     * @param error - The Error instance to format
+     * @returns Formatted string ready for display
+     */
+    protected compile_Error(error: Error): string;
+    /**
+     * Generate timestamp string for log messages
+     *
+     * Format: MM:SS:mmm (minutes:seconds:milliseconds)
+     * This provides sufficient precision for debugging while remaining readable
+     *
+     * @returns Formatted timestamp string
+     *
+     * @example
+     * Returns: "15:42:137" for 3:42:15 PM and 137 milliseconds
+     */
+    protected getTime(): string;
+}
+
+export { A_Logger };