@adaas/a-utils 0.1.39 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.39",
+  "version": "0.2.1",
   "description": "A-Utils is a set of utilities that are used across the ADAAS ecosystem. This package is designed to be a collection of utilities that are used across the ADAAS ecosystem.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",
@@ -80,7 +80,8 @@
     "build": "tsup --config tsup.config.ts"
   },
   "dependencies": {
-    "@adaas/a-concept": "^0.1.58"
+    "@adaas/a-concept": "^0.1.61",
+    "@adaas/a-frame": "^0.0.2"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

package/src/lib/A-Channel/A-Channel.component.ts

@@ -3,6 +3,7 @@ import { A_ChannelError } from "./A-Channel.error";
 import { A_ChannelFeatures } from "./A-Channel.constants";
 import { A_OperationContext } from "../A-Operation/A-Operation.context";
 import { A_ChannelRequest } from "./A-ChannelRequest.context";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * A-Channel - A powerful, extensible communication channel component
@@ -48,6 +49,11 @@ import { A_ChannelRequest } from "./A-ChannelRequest.context";
  * 
  * @see {@link ./README.md} For complete documentation and examples
  */
+@A_Frame.Namespace('A-Utils')
+@A_Frame.Component({
+    name: 'A-Channel',
+    description: 'Component uses as abstract channel for communication patterns. Can be inherited and extended to implement custom channels.'
+})
 export class A_Channel extends A_Component {
 
     /**

package/src/lib/A-Channel/A-ChannelRequest.context.ts

@@ -1,6 +1,13 @@
+import { A_Frame } from "@adaas/a-frame";
 import { A_OperationContext } from "../A-Operation/A-Operation.context";
 import { A_ChannelRequestStatuses } from "./A-Channel.constants";
 
+
+
+@A_Frame.Fragment({
+    name: 'A-ChannelRequest',
+    description: 'Context for managing channel requests. It encapsulates the request parameters and the result including status and data.'
+})
 export class A_ChannelRequest<
     _ParamsType extends Record<string, any> = Record<string, any>,
     _ResultType extends Record<string, any> = Record<string, any>,

package/src/lib/A-Command/A-Command.entity.ts

@@ -10,13 +10,14 @@ import {
     A_CommandTransitions,
     A_CommandEvent
 } from "./A-Command.constants";
-import {  A_Context, A_Dependency, A_Entity, A_Error, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_Context, A_Dependency, A_Entity, A_Error, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
 import { A_CommandError } from "./A-Command.error";
 import { A_StateMachine } from "../A-StateMachine/A-StateMachine.component";
 import { A_StateMachineFeatures } from "../A-StateMachine/A-StateMachine.constants";
 import { A_Logger } from "../A-Logger/A-Logger.component";
 import { A_StateMachineTransition } from "../A-StateMachine/A-StateMachineTransition.context";
 import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * A_Command - Advanced Command Pattern Implementation
@@ -77,6 +78,11 @@ import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
  * console.log('Status:', command.status);
  * ```
  */
+@A_Frame.Entity({
+    namespace: 'A-Utils',
+    name: 'A-Command',
+    description: 'Advanced Command Pattern Implementation with full lifecycle management, event handling, and state persistence. This entity allows to execute commands in distributed environment across multiple services.'
+})
 export class A_Command<
     InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init,
     ResultType extends Record<string, any> = Record<string, any>,

package/src/lib/A-Command/A-Command.error.ts

@@ -8,7 +8,6 @@ export class A_CommandError extends A_Error {
 
     static readonly ExecutionError = 'A-Command Execution Error';
 
-
     static readonly ResultProcessingError = 'A-Command Result Processing Error';
 
 

package/src/lib/A-Config/A-Config.container.ts

@@ -6,8 +6,15 @@ import { A_ConfigError } from "./A-Config.error";
 import { FileConfigReader } from "./components/FileConfigReader.component";
 import { ENVConfigReader } from "./components/ENVConfigReader.component";
 import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "./A-Config.constants";
+import { A_Frame } from "@adaas/a-frame";
 
 
+
+@A_Frame.Container({
+    namespace: 'A-Utils',
+    name: 'A-ConfigLoader',
+    description: 'Container responsible for loading and initializing the A_Config component based on the environment and available configuration sources. It can be useful for application that need a separated configuration management and sharable across multiple containers.'
+})
 export class A_ConfigLoader extends A_Container {
 
     private reader!: ConfigReader

package/src/lib/A-Config/A-Config.context.ts

@@ -3,8 +3,15 @@ import { A_TYPES__ConfigContainerConstructor } from "./A-Config.types";
 import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
 import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "./A-Config.constants";
 import { A_ConfigError } from "./A-Config.error";
+import { A_Frame } from "@adaas/a-frame";
 
 
+
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-Config',
+    description: 'Configuration management context that provides structured access to application configuration variables, supporting defaults and strict mode for enhanced reliability. Default environment variables are included for comprehensive configuration handling.'
+})
 export class A_Config<
     T extends Array<string | A_TYPES__ConceptENVVariables[number]> = any[]
 > extends A_ExecutionContext<

package/src/lib/A-Config/components/ConfigReader.component.ts

@@ -3,10 +3,16 @@ import { A_Config } from "../A-Config.context";
 import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "../A-Config.constants";
 import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
 import { A_Memory } from "../../A-Memory/A-Memory.component";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * Config Reader
  */
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'ConfigReader',
+    description: 'Abstract component for reading configuration data from various sources such as files, environment variables, or remote services. This component can be extended to implement specific configuration reading strategies.'
+})
 export class ConfigReader extends A_Component {
 
     protected DEFAULT_ALLOWED_TO_READ_PROPERTIES = [

package/src/lib/A-Config/components/ENVConfigReader.component.ts

@@ -2,8 +2,15 @@ import { A_Concept, A_Feature, A_FormatterHelper, A_Inject, A_TYPES__ConceptENVV
 import { ConfigReader } from "./ConfigReader.component";
 import { A_Config } from "../A-Config.context";
 import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
+import { A_Frame } from "@adaas/a-frame";
 
 
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'ENVConfigReader',
+    description: 'Configuration reader that sources configuration data from environment variables. It supports loading variables from a .env file and maps them to the configuration context, making it suitable for applications running in diverse environments such as local development, staging, and production.'
+})
 export class ENVConfigReader extends ConfigReader {
 
 

package/src/lib/A-Config/components/FileConfigReader.component.ts

@@ -1,6 +1,14 @@
 import { A_Context, A_FormatterHelper } from "@adaas/a-concept";
 import { ConfigReader } from "./ConfigReader.component";
+import { A_Frame } from "@adaas/a-frame";
 
+
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'FileConfigReader',
+    description: 'Configuration reader that loads configuration data from a JSON file located in the application root directory. It reads the file named after the current concept with a .conf.json extension and parses its contents into the configuration context.'
+})
 export class FileConfigReader extends ConfigReader {
 
     private FileData: Map<string, any> = new Map<string, any>();

package/src/lib/A-Execution/A-Execution.context.ts

@@ -1,7 +1,14 @@
 import { A_Fragment, A_Meta, A_TYPES__Fragment_Serialized } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
+
+@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.'
+})
 export class A_ExecutionContext<
     _MetaType extends Record<string, any> = Record<string, any>,
     _SerializedType extends Record<string, any> = Record<string, any>
@@ -37,8 +44,9 @@ export class A_ExecutionContext<
         return this._meta.get(key);
     }
 
-    set<K extends keyof _MetaType>(key: K, value: _MetaType[K]): void {
+    set<K extends keyof _MetaType>(key: K, value: _MetaType[K]): this {
         this._meta.set(key, value);
+        return this;
     }
 
     has(key: keyof _MetaType): boolean {
@@ -49,8 +57,9 @@ export class A_ExecutionContext<
         this._meta.delete(key);
     }
 
-    clear(): void {
+    clear(): this {
         this._meta.clear();
+        return this;
     }
 
 

package/src/lib/A-Logger/A-Logger.component.ts

@@ -12,6 +12,7 @@ import {
     A_LOGGER_SAFE_RANDOM_COLORS,
     A_LOGGER_TERMINAL
 } from "./A-Logger.constants";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * A_Logger - Advanced Logging Component with Scope-based Output Formatting
@@ -78,6 +79,11 @@ import {
  * const logger = new A_Logger(scope, config);
  * ```
  */
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A_Logger',
+    description: 'Advanced Logging Component with Scope-based Output Formatting that provides color-coded console output, multi-type support, and configurable log levels for enhanced debugging and monitoring.'
+})
 export class A_Logger extends A_Component {
 
     // =============================================
@@ -277,10 +283,10 @@ export class A_Logger extends A_Component {
         // Continuation lines: terminal_width - scope_padding - pipe_length
         const scopeHeaderLength = this.formattedScope.length + 4 + this.getTime().length + 4; // [scope] |time| 
         const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
-        
+
         const firstLineMaxWidth = Math.max(this.TERMINAL_WIDTH - scopeHeaderLength - 1, 20); // -1 for space
         const continuationMaxWidth = Math.max(this.TERMINAL_WIDTH - continuationIndent.length, 20);
-        
+
         // If text fits on first line, return as is
         if (isFirstLine && text.length <= firstLineMaxWidth) {
             return [text];
@@ -496,14 +502,14 @@ export class A_Logger extends A_Component {
         // Apply terminal width wrapping to long JSON string values
         const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
         const maxJsonLineWidth = this.TERMINAL_WIDTH - continuationIndent.length - 4; // -4 for JSON indentation
-        
+
         // Split into lines and wrap long string values
         const lines = jsonString.split('\n').map(line => {
             // Check if this line contains a long string value
             const stringValueMatch = line.match(/^(\s*"[^"]+":\s*")([^"]+)(".*)?$/);
             if (stringValueMatch && stringValueMatch[2].length > maxJsonLineWidth - stringValueMatch[1].length - (stringValueMatch[3] || '').length) {
                 const [, prefix, value, suffix = ''] = stringValueMatch;
-                
+
                 // Wrap the string value if it's too long
                 if (value.length > maxJsonLineWidth - prefix.length - suffix.length) {
                     const wrappedValue = this.wrapJsonStringValue(value, maxJsonLineWidth - prefix.length - suffix.length);
@@ -528,7 +534,7 @@ export class A_Logger extends A_Component {
         if (value.length <= maxWidth) {
             return value;
         }
-        
+
         // For JSON string values, truncate with ellipsis to maintain JSON validity
         // This prevents the JSON from becoming unreadable due to excessive wrapping
         // while still showing the most important part of the string
@@ -558,7 +564,7 @@ export class A_Logger extends A_Component {
         // For terminal, apply intelligent text wrapping
         const wrappedLines = this.wrapText(str, scopePadding, !shouldAddNewline);
         const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
-        
+
         // Format the wrapped lines with proper indentation
         const formattedLines = wrappedLines.map((line, index) => {
             if (index === 0 && !shouldAddNewline) {
@@ -569,7 +575,7 @@ export class A_Logger extends A_Component {
                 return `${continuationIndent}${line}`;
             }
         });
-        
+
         if (shouldAddNewline) {
             return '\n' + formattedLines.join('\n');
         } else {
@@ -795,30 +801,30 @@ ${scopePadding}|-------------------------------
         lines.push(separator);
         lines.push(`${continuationIndent}A_ERROR: ${error.code}`);
         lines.push(separator);
-        
+
         // Format and wrap error message and description
         const errorMessage = this.wrapText(`Message: ${error.message}`, continuationIndent, false);
         const errorDescription = this.wrapText(`Description: ${error.description}`, continuationIndent, false);
-        
+
         lines.push(...errorMessage.map(line => `${continuationIndent}${line}`));
         lines.push(...errorDescription.map(line => `${continuationIndent}${line}`));
-        
+
         // Show original error FIRST (more important for debugging)
         if (error.originalError) {
             lines.push(separator);
             lines.push(`${continuationIndent}ORIGINAL ERROR:`);
             lines.push(separator);
-            
+
             const originalMessage = this.wrapText(`${error.originalError.name}: ${error.originalError.message}`, continuationIndent, false);
             lines.push(...originalMessage.map(line => `${continuationIndent}${line}`));
-            
+
             if (error.originalError.stack) {
                 lines.push(`${continuationIndent}Stack trace:`);
                 const stackLines = this.formatStackTrace(error.originalError.stack, continuationIndent);
                 lines.push(...stackLines);
             }
         }
-        
+
         // Then show A_Error stack trace
         if (error.stack) {
             lines.push(separator);
@@ -827,16 +833,16 @@ ${scopePadding}|-------------------------------
             const stackLines = this.formatStackTrace(error.stack, continuationIndent);
             lines.push(...stackLines);
         }
-        
+
         // Documentation link at the end
         if (error.link) {
             lines.push(separator);
             const linkText = this.wrapText(`Documentation: ${error.link}`, continuationIndent, false);
             lines.push(...linkText.map(line => `${continuationIndent}${line}`));
         }
-        
+
         lines.push(separator);
-        
+
         return lines.join('\n');
     }
 
@@ -850,20 +856,20 @@ ${scopePadding}|-------------------------------
     private formatStackTrace(stack: string, baseIndent: string): string[] {
         const stackLines = stack.split('\n');
         const formatted: string[] = [];
-        
+
         stackLines.forEach((line, index) => {
             if (line.trim()) {
                 // Add extra indentation for stack trace lines
                 const stackIndent = index === 0 ? baseIndent : `${baseIndent}  `;
                 const wrappedLines = this.wrapText(line.trim(), stackIndent, false);
-                formatted.push(...wrappedLines.map(wrappedLine => 
-                    index === 0 && wrappedLine === wrappedLines[0] 
+                formatted.push(...wrappedLines.map(wrappedLine =>
+                    index === 0 && wrappedLine === wrappedLines[0]
                         ? `${baseIndent}${wrappedLine}`
                         : `${baseIndent}  ${wrappedLine}`
                 ));
             }
         });
-        
+
         return formatted;
     }
 
@@ -888,11 +894,11 @@ ${scopePadding}|-------------------------------
         lines.push(separator);
         lines.push(`${continuationIndent}ERROR: ${error.name}`);
         lines.push(separator);
-        
+
         // Format and wrap error message
         const errorMessage = this.wrapText(`Message: ${error.message}`, continuationIndent, false);
         lines.push(...errorMessage.map(line => `${continuationIndent}${line}`));
-        
+
         // Format stack trace if available
         if (error.stack) {
             lines.push(separator);
@@ -901,9 +907,9 @@ ${scopePadding}|-------------------------------
             const stackLines = this.formatStackTrace(error.stack, continuationIndent);
             lines.push(...stackLines);
         }
-        
+
         lines.push(separator);
-        
+
         return lines.join('\n');
     }
 

package/src/lib/A-Manifest/A-Manifest.context.ts

@@ -2,11 +2,17 @@ import { A_Component, A_Fragment, A_TypeGuards, A_TYPES__Component_Constructor }
 import { A_UTILS_TYPES__Manifest_Init, A_UTILS_TYPES__Manifest_ComponentLevelConfig, A_UTILS_TYPES__Manifest_AllowedComponents, A_UTILS_TYPES__ManifestRule, A_UTILS_TYPES__ManifestQuery } from "./A-Manifest.types";
 import { A_ManifestError } from "./A-Manifest.error";
 import { A_ManifestChecker } from "./classes/A-ManifestChecker.class";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
 
 
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-Manifest',
+    description: 'A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules.'
+})
 export class A_Manifest extends A_Fragment {
 
     private rules: A_UTILS_TYPES__ManifestRule[] = [];

package/src/lib/A-Memory/A-Memory.component.ts

@@ -4,8 +4,15 @@ import { A_MemoryContext } from "./A-Memory.context";
 import { A_MemoryError } from "./A-Memory.error";
 import { A_OperationContext } from "../A-Operation/A-Operation.context";
 import { A_MemoryOperationContext } from "./A-Memory.types";
+import { A_Frame } from "@adaas/a-frame";
 
 
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-Memory',
+    description: 'In-memory data storage component that provides a simple key-value store with asynchronous operations. It supports basic memory operations such as get, set, has, drop, and clear, along with lifecycle management and error handling features. This components features can be extended with other components to provide ability store data across multiple storage, or extract data from multiple external sources. Good example is to store some runtime data that needs to be shared across multiple containers or concepts.'
+})
 export class A_Memory<
     _StorageType extends Record<string, any> = Record<string, any>,
     _SerializedType extends Record<string, any> = Record<string, any>

package/src/lib/A-Memory/A-Memory.context.ts

@@ -1,9 +1,15 @@
 import { A_Error, A_Fragment, A_TYPES__Fragment_Serialized } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
 import { error } from "console";
 
 
 
 
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-MemoryContext',
+    description: 'In-memory context fragment that provides a simple key-value store for temporary data storage during application runtime. It allows setting, getting, deleting, and checking the existence of key-value pairs, facilitating quick access to transient data without persistent storage. This context is useful for scenarios where data needs to be shared across different components or operations within the same execution context.'
+})
 export class A_MemoryContext<
     _MemoryType extends Record<string, any> = Record<string, any>,
     _SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized

package/src/lib/A-Operation/A-Operation.context.ts

@@ -1,7 +1,15 @@
 import { A_Error, A_Fragment } from "@adaas/a-concept";
 import { A_Operation_Serialized, A_Operation_Storage } from "./A-Operation.types";
 import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
+import { A_Frame } from "@adaas/a-frame";
 
+
+
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-OperationContext',
+    description: 'Operation execution context that encapsulates the metadata and serialized data related to a specific operation. It provides structured access to operation parameters, results, and error handling, facilitating the management of operation lifecycles within the application.'
+})
 export class A_OperationContext<
     _AllowedOperations extends string = string,
     _ParamsType extends Record<string, any> = Record<string, any>,

package/src/lib/A-Polyfill/A-Polyfill.component.ts

@@ -8,7 +8,16 @@ import { A_PathPolyfillClass } from "./classes/A-Path-Polyfill.class";
 import { A_UrlPolyfillClass } from "./classes/A-Url-Polyfill.class";
 import { A_BufferPolyfillClass } from "./classes/A-Buffer-Polyfill.class";
 import { A_ProcessPolyfillClass } from "./classes/A-Process-Polyfill.class";
+import { A_Frame } from "@adaas/a-frame";
 
+
+
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-Polyfill',
+    description: 'Polyfill component that provides cross-environment compatibility for Node.js core modules such as fs, crypto, http, https, path, url, buffer, and process. It dynamically loads appropriate polyfills based on the execution environment (Node.js or browser), enabling seamless usage of these modules in different contexts.'
+})
 export class A_Polyfill extends A_Component {
 
     protected _fsPolyfill!: A_FSPolyfillClass;

package/src/lib/A-Route/A-Route.entity.ts

@@ -1,7 +1,14 @@
 import { A_Fragment } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame';
 
 
 
+
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-Route',
+    description: 'Route fragment that defines URL patterns for routing purposes. It supports dynamic parameters and query extraction, allowing for flexible route definitions. This fragment can be used in routing systems to match incoming URLs against defined routes and extract relevant parameters and query strings.'
+})
 export class A_Route<
     _TParams extends Record<string, any> = Record<string, any>,
     _TQuery extends Record<string, any> = Record<string, any>

package/src/lib/A-Schedule/A-Schedule.component.ts

@@ -1,9 +1,16 @@
-import { A_Component, A_TypeGuards } from "@adaas/a-concept";
+import { A_Component, A_Fragment, A_TypeGuards } from "@adaas/a-concept";
 import { A_ScheduleObject } from "./A-ScheduleObject.class";
 import { A_UTILS_TYPES__ScheduleObjectCallback, A_UTILS_TYPES__ScheduleObjectConfig } from "./A-Schedule.types";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-Schedule',
+    description: 'Scheduling component that allows scheduling of callbacks to be executed at specific times or after certain delays. It provides methods to schedule callbacks based on Unix timestamps or ISO date strings, as well as a method to execute callbacks after a specified delay in milliseconds. This component is useful for managing timed operations within an application.'
+})
 export class A_Schedule extends A_Component {
 
     /**

package/src/lib/A-Service/A-Service.container.ts

@@ -4,6 +4,7 @@ import { A_Polyfill } from "../A-Polyfill/A-Polyfill.component";
 import { A_Config } from "../A-Config/A-Config.context";
 import { A_Logger } from "../A-Logger/A-Logger.component";
 import { A_Service_Error } from "./A-Service.error";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
@@ -13,6 +14,11 @@ import { A_Service_Error } from "./A-Service.error";
  * Depending on the provided config and configuration, it will load the necessary components and start the service.
  * 
  */
+@A_Frame.Container({
+    namespace: 'A-Utils',
+    name: 'A-Service',
+    description: 'Service container that manages the lifecycle of various types of services, such as HTTP servers and workers or UI loader. It dynamically loads necessary components based on the provided configuration and orchestrates the start and stop processes, ensuring proper error handling and extensibility through feature hooks.'
+})
 export class A_Service extends A_Container {
 
 

package/src/lib/A-Signal/components/A-SignalBus.component.ts

@@ -5,6 +5,7 @@ import { A_SignalConfig } from "../context/A-SignalConfig.context";
 import { A_Config } from "../../A-Config/A-Config.context";
 import { A_Logger } from "../../A-Logger/A-Logger.component";
 import { A_Signal } from "../entities/A-Signal.entity";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
@@ -18,6 +19,11 @@ import { A_Signal } from "../entities/A-Signal.entity";
  * 
  * The component itself is stateless and all methods uses only parameters (context) is provided with.
  */
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-SignalBus',
+    description: 'Signal bus component that manages the emission and state of signals within a given scope. It listens for emitted signals, updates their state, and forwards them to registered watchers. The bus ensures a consistent signal vector structure based on the defined configuration, facilitating signal management across multiple components.'
+})
 export class A_SignalBus extends A_Component {
 
 

package/src/lib/A-Signal/context/A-SignalConfig.context.ts

@@ -1,6 +1,7 @@
 import { A_CommonHelper, A_Context, A_Fragment, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
 import { A_SignalConfig_Init } from "../A-Signal.types";
 import { A_Signal } from "../entities/A-Signal.entity";
+import { A_Frame } from "@adaas/a-frame";
 
 
 
@@ -11,6 +12,11 @@ import { A_Signal } from "../entities/A-Signal.entity";
  * e.g. [A_RouterWatcher, A_ScopeWatcher, A_LoggerWatcher]
  * This structure then should be used for any further processing of signals within the scope.
  */
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-SignalConfig',
+    description: 'Signal configuration fragment that defines the structure and types of signals within a given scope. It allows specifying the expected signal constructors and their order, facilitating consistent signal management and processing across components that emit or listen to signals.'
+})
 export class A_SignalConfig extends A_Fragment {
 
     protected _structure?: Array<A_TYPES__Entity_Constructor<A_Signal>>;

package/src/lib/A-Signal/context/A-SignalState.context.ts

@@ -1,6 +1,7 @@
 import { A_Context, A_Fragment, A_TYPES__Component_Constructor } from "@adaas/a-concept";
 import { A_Signal } from "../entities/A-Signal.entity";
 import { A_SignalVector } from "../entities/A-SignalVector.entity";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * A_SignalState manages the latest state of all signals within a given scope.
@@ -15,6 +16,11 @@ import { A_SignalVector } from "../entities/A-SignalVector.entity";
  * - Signal instances and their emitted value types
  * - Vector structure and the data it contains
  */
+@A_Frame.Fragment({
+    namespace: 'A-Utils',
+    name: 'A-SignalState',
+    description: 'Manages the latest state of all signals within a given scope, maintaining a mapping between signal constructors and their most recently emitted values.'
+})
 export class A_SignalState<
     TSignalData extends Record<string, any> = Record<string, any>
 > extends A_Fragment {

package/src/lib/A-Signal/entities/A-Signal.entity.ts

@@ -1,6 +1,7 @@
 import { A_Entity, A_Scope } from "@adaas/a-concept";
 import { A_Signal_Init, A_Signal_Serialized } from "../A-Signal.types";
 import { A_SignalFeatures } from "../A-Signal.constants";
+import { A_Frame } from "@adaas/a-frame";
 
 /**
  * A Signal Entity is an individual signal instance that carries data.
@@ -15,6 +16,11 @@ import { A_SignalFeatures } from "../A-Signal.constants";
  * Signals are typically used in scenarios where the current state is more important than individual events, 
  * such as monitoring systems, real-time dashboards, or stateful applications.
  */
+@A_Frame.Entity({
+    namespace: 'A-Utils',
+    name: 'A-Signal',
+    description: 'A Signal Entity represents an individual signal instance that carries data, used for managing state within an application context. Signals are designed to reflect the current state rather than individual events, making them suitable for scenarios where state monitoring and real-time updates are essential.'
+})
 export class A_Signal<
     _TSignalDataType extends Record<string, any> = Record<string, any>
 > extends A_Entity<A_Signal_Init<_TSignalDataType>, A_Signal_Serialized<_TSignalDataType>> {

package/src/lib/A-Signal/entities/A-SignalVector.entity.ts

@@ -2,6 +2,7 @@ import { A_Entity, A_Scope, A_TYPES__Component_Constructor, A_TYPES__Entity_Cons
 import { A_SignalVector_Serialized, A_SignalVector_Init } from "../A-Signal.types";
 import { A_Signal } from "./A-Signal.entity";
 import { A_SignalVectorFeatures } from "../A-Signal.constants";
+import { A_Frame } from "@adaas/a-frame";
 
 
 /**
@@ -14,6 +15,11 @@ import { A_SignalVectorFeatures } from "../A-Signal.constants";
  * @template TSignalsConstructors - Array of signal constructor types (e.g., [typeof MySignal, typeof CustomSignal])
  * @template TSignals - Array of signal instances derived from constructors
  */
+@A_Frame.Entity({
+    namespace: 'A-Utils',
+    name: 'A-SignalVector',
+    description: 'A Signal Vector Entity represents a collection of signals structured in a specific way, allowing for batch processing and transmission of related signals as a unified state representation.'
+})
 export class A_SignalVector<
     TSignals extends Array<A_Signal> = Array<A_Signal>,
     TSignalsConstructors extends Array<A_TYPES__Entity_Constructor<A_Signal>> = TSignals extends Array<infer U> ? U extends A_Signal ? A_TYPES__Entity_Constructor<U>[] : never : never